Feature/php incluse resolver (#168)

* Incluse resolver first shot

* Update pom.xml

* Update lint_test_compile.yml

* Incluse resolver completed

Author: LeBoufty

.github/workflows/lint_test_compile.yml

@@ -24,7 +24,7 @@ jobs:
         run: deno lint
 
       - name: Deno fmt (check)
-        run: deno fmt --check --ignore=examples/java/websocket/**/*.html
+        run: deno fmt --check --ignore=examples/**
 
   tests:
     runs-on: ubuntu-latest

examples/java/websocket/pom.xml

@@ -1,5 +1,9 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<?xml version="1.0" encoding="UTF-8" ?>
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
+>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>websocket</artifactId>
 	<parent>

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

@@ -0,0 +1,35 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { getPHPFilesMap } from "../testFiles/index.ts";
+import { PHPRegistree } from "../registree/index.ts";
+import { PHPIncluseResolver } from "./index.ts";
+import { INCLUDE, USE } from "../testFiles/constants.ts";
+
+describe("PHP Incluse resolver", () => {
+  const files = getPHPFilesMap();
+  const registree = new PHPRegistree(files);
+  const resolver = new PHPIncluseResolver(registree);
+
+  test("resolves use directives", () => {
+    const imports = resolver.resolveImports(registree.registry.files.get(USE)!);
+    expect(imports.unresolved.namespaces.length).toBe(1);
+    expect(imports.unresolved.namespaces).toContainEqual("I\\Do\\Not\\Exist");
+    expect(imports.resolved.get("f")).toBeDefined(); // nested.php
+    expect(imports.resolved.get("my_function")).toBeDefined(); // learnphp function
+    expect(imports.resolved.get("MyClass")).toBeDefined(); // learnphp class
+    expect(imports.resolved.get("wheels")).toBeDefined(); // leanrphp variable
+  });
+
+  test("resolves include directives", () => {
+    const imports = resolver.resolveImports(
+      registree.registry.files.get(INCLUDE)!,
+    );
+    expect(imports.unresolved.paths.length).toBe(1);
+    expect(imports.unresolved.paths).toContainEqual("unresolved.php");
+    expect(imports.resolved.get("f")).toBeDefined(); // nested.php
+    expect(imports.resolved.get("defined_in_used_file")).toBeDefined(); // use.php
+    expect(imports.resolved.get("my_function")).toBeDefined(); // learnphp function
+    expect(imports.resolved.get("MyClass")).toBeDefined(); // learnphp class
+    expect(imports.resolved.get("wheels")).toBeDefined(); // leanrphp variable
+  });
+});

src/languagePlugins/php/incluseResolver/index.ts

@@ -0,0 +1,157 @@
+import type { PHPRegistree } from "../registree/index.ts";
+import { type PHPFile, type PHPNode, SymbolNode } from "../registree/types.ts";
+import type { PHPImports } from "./types.ts";
+import { PHP_INCLUDE_QUERY, PHP_USE_DETECTION_QUERY } from "./queries.ts";
+import type Parser from "tree-sitter";
+import { dirname, join } from "@std/path";
+
+export class PHPIncluseResolver {
+  registree: PHPRegistree;
+  imports: Map<string, PHPImports>;
+
+  constructor(registree: PHPRegistree) {
+    this.registree = registree;
+    this.imports = new Map();
+  }
+
+  resolveImports(file: PHPFile) {
+    if (this.imports.has(file.path)) {
+      return this.imports.get(file.path)!;
+    }
+    const useImports = this.#resolveUseDirectives(file);
+    const includeImports = this.#resolveIncludeDirectives(file);
+    const imports: PHPImports = {
+      resolved: new Map([
+        ...useImports.resolved,
+        ...includeImports.resolved,
+      ]),
+      unresolved: {
+        paths: [
+          ...useImports.unresolved.paths,
+          ...includeImports.unresolved.paths,
+        ],
+        namespaces: [
+          ...useImports.unresolved.namespaces,
+          ...includeImports.unresolved.namespaces,
+        ],
+      },
+    };
+    this.imports.set(file.path, imports);
+    return imports;
+  }
+
+  #resolveUseDirectives(file: PHPFile): PHPImports {
+    const useDirectives = PHP_USE_DETECTION_QUERY.captures(file.rootNode);
+    if (!useDirectives) {
+      throw new Error(`Error when paring use directives for ${file.path}`);
+    }
+    const imports: PHPImports = {
+      resolved: new Map(),
+      unresolved: {
+        paths: [],
+        namespaces: [],
+      },
+    };
+    for (const use of useDirectives) {
+      let name: string | undefined = undefined;
+      let node: PHPNode | undefined = undefined;
+      for (const clause of use.node.namedChildren) {
+        if (clause.type === "namespace_aliasing_clause") {
+          name = clause.text;
+        } else {
+          node = this.registree.tree.findNode(clause.text);
+          if (node && !name) {
+            name = node.name;
+          } else if (!node && !name) {
+            name = clause.text;
+          }
+        }
+      }
+      if (node && name) {
+        if (node instanceof SymbolNode) {
+          imports.resolved.set(name, node.symbols);
+        } else {
+          for (const [k, v] of node.children) {
+            if (v instanceof SymbolNode) {
+              imports.resolved.set(k, v.symbols);
+            }
+          }
+        }
+      } else if (name) {
+        imports.unresolved.namespaces.push(name);
+      }
+    }
+    return imports;
+  }
+
+  #splitBinary(binary: Parser.SyntaxNode): Parser.SyntaxNode[] {
+    const left = binary.childForFieldName("left")!;
+    const right = binary.childForFieldName("right")!;
+    const leftArr = [];
+    const rightArr = [];
+    if (left.type === "binary_expression") {
+      leftArr.push(...this.#splitBinary(left));
+    } else {
+      leftArr.push(left);
+    }
+    if (right.type === "binary_expression") {
+      rightArr.push(...this.#splitBinary(right));
+    } else {
+      rightArr.push(right);
+    }
+    return [...leftArr, ...rightArr];
+  }
+
+  #resolveIncludeDirectives(file: PHPFile) {
+    const includeDirectives = PHP_INCLUDE_QUERY.captures(file.rootNode);
+    if (!includeDirectives) {
+      throw new Error(`Error when parsing include directives for ${file.path}`);
+    }
+    const imports: PHPImports = {
+      resolved: new Map(),
+      unresolved: {
+        paths: [],
+        namespaces: [],
+      },
+    };
+    for (const include of includeDirectives) {
+      if (include.name === "includestr") {
+        const path = include.node.text;
+        const importedfile = this.registree.registry.getFile(path, file.path);
+        if (importedfile) {
+          for (const [k, v] of importedfile.symbols) {
+            if (imports.resolved.has(k)) {
+              imports.resolved.get(k)!.push(...v);
+            } else {
+              imports.resolved.set(k, v);
+            }
+          }
+        } else {
+          imports.unresolved.paths.push(path);
+        }
+      } else if (include.name === "includebin") {
+        const fileparts = this.#splitBinary(include.node)
+          .map((n) => n.text === "__DIR__" ? dirname(file.path) : n.text)
+          .filter((n) => n !== "")
+          .map((n) => n.replace(/['"]/g, ""));
+        const filepath = join(fileparts[0], ...fileparts.slice(1));
+        const importedfile = this.registree.registry.getFile(
+          filepath,
+          file.path,
+        );
+        if (importedfile) {
+          for (const [k, v] of importedfile.symbols) {
+            if (imports.resolved.has(k)) {
+              imports.resolved.get(k)!.push(...v);
+            } else {
+              imports.resolved.set(k, v);
+            }
+          }
+        } else {
+          imports.unresolved.paths.push(filepath);
+        }
+      }
+    }
+    return imports;
+  }
+}

src/languagePlugins/php/incluseResolver/queries.ts

@@ -0,0 +1,26 @@
+import Parser from "tree-sitter";
+import { phpParser } from "../../../helpers/treeSitter/parsers.ts";
+
+export const PHP_USE_DETECTION_QUERY = new Parser.Query(
+  phpParser.getLanguage(),
+  `
+  (namespace_use_declaration
+    (namespace_use_clause) @use
+  )
+  `,
+);
+
+export const PHP_INCLUDE_QUERY = new Parser.Query(
+  phpParser.getLanguage(),
+  `
+  (include_expression (string (string_content) @includestr))
+  (include_once_expression (string (string_content) @includestr))
+  (require_expression (string (string_content) @includestr))
+  (require_once_expression (string (string_content) @includestr))
+
+  (include_expression (binary_expression) @includebin)
+  (include_once_expression (binary_expression) @includebin)
+  (require_expression (binary_expression) @includebin)
+  (require_once_expression (binary_expression) @includebin)
+  `,
+);

src/languagePlugins/php/incluseResolver/types.ts

@@ -0,0 +1,9 @@
+import type { ExportedSymbol } from "../exportResolver/types.ts";
+
+export interface PHPImports {
+  resolved: Map<string, ExportedSymbol[]>;
+  unresolved: {
+    paths: string[];
+    namespaces: string[];
+  };
+}

src/languagePlugins/php/registree/types.ts

@@ -4,6 +4,7 @@ import type {
   ExportedSymbol,
 } from "../exportResolver/types.ts";
 import { PHPExportResolver } from "../exportResolver/index.ts";
+import { dirname, join } from "@std/path";
 
 export interface PHPNode {
   name: string;
@@ -42,6 +43,29 @@ export class PHPTree extends NamespaceNode {
     }
   }
 
+  findNode(name: string): PHPNode | undefined {
+    if (name === "") {
+      return this;
+    } else {
+      const packageparts = name.split("\\").reverse();
+      let part = packageparts.pop()!;
+      if (part === "") {
+        part = packageparts.pop()!;
+      }
+      let current = this.children.get(part);
+      if (!current) {
+        return undefined;
+      }
+      while (packageparts.length > 0) {
+        if (!current) {
+          return undefined;
+        }
+        current = current.children.get(packageparts.pop()!);
+      }
+      return current;
+    }
+  }
+
   addNamespaces(namespaces: ExportedNamespace[]) {
     for (const ns of namespaces) {
       const nsparts = ns.name.split("\\");
@@ -106,4 +130,20 @@ export class PHPRegistry {
       symbols,
     });
   }
+
+  getFile(path: string, origin: string): PHPFile | undefined {
+    const filepaths = Array.from(this.files.keys());
+    // 1. Check current file's directory
+    const sourceDir = dirname(origin);
+    const pathFromRelative = join(sourceDir, path).replace(/\\/g, "/");
+    const corresponding1 = filepaths.find((f) => f === pathFromRelative);
+    if (corresponding1) {
+      return this.files.get(corresponding1);
+    }
+    // 2. Check from workspace root
+    const corresponding2 = filepaths.find((f) => f === path);
+    if (corresponding2) {
+      return this.files.get(corresponding2);
+    }
+  }
 }

src/languagePlugins/php/testFiles/constants.ts

@@ -3,3 +3,5 @@ import { join } from "@std/path";
 
 export const LEARN_PHP = join(phpFilesFolder, "learnphp.php");
 export const NESTED = join(phpFilesFolder, "nested.php");
+export const INCLUDE = join(phpFilesFolder, "include.php");
+export const USE = join(phpFilesFolder, "use.php");

src/languagePlugins/php/testFiles/phpFiles/include.php

@@ -0,0 +1,6 @@
+<?php
+
+include 'learnphp.php';
+include __DIR__ . '/nested.php';
+include __DIR__ . '/../phpFiles/use.php';
+include 'unresolved.php';

src/languagePlugins/php/testFiles/phpFiles/use.php

@@ -0,0 +1,8 @@
+<?php
+namespace All\My;
+
+$defined_in_used_file = 0;
+
+use All\My\Fellas;
+use My\Namespace;
+use I\Do\Not\Exist;