Recursive include resolution

Author: LeBoufty

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

@@ -12,7 +12,7 @@ describe("PHP Incluse resolver", () => {
 
   test("resolves use directives", () => {
     const imports = resolver.resolveImports(registree.registry.files.get(USE)!);
-    expect(imports.unresolved.namespaces.length).toBe(1);
+    expect(imports.unresolved.namespaces.size).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
@@ -24,7 +24,8 @@ describe("PHP Incluse resolver", () => {
     const imports = resolver.resolveImports(
       registree.registry.files.get(INCLUDE)!,
     );
-    expect(imports.unresolved.paths.length).toBe(1);
+    console.log(Array.from(imports.unresolved.paths.values()));
+    expect(imports.unresolved.paths.size).toBe(4);
     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

src/languagePlugins/php/incluseResolver/index.ts

@@ -26,14 +26,12 @@ export class PHPIncluseResolver {
         ...includeImports.resolved,
       ]),
       unresolved: {
-        paths: [
-          ...useImports.unresolved.paths,
-          ...includeImports.unresolved.paths,
-        ],
-        namespaces: [
-          ...useImports.unresolved.namespaces,
-          ...includeImports.unresolved.namespaces,
-        ],
+        paths: useImports.unresolved.paths.union(
+          includeImports.unresolved.paths,
+        ),
+        namespaces: useImports.unresolved.namespaces.union(
+          includeImports.unresolved.namespaces,
+        ),
       },
     };
     this.imports.set(file.path, imports);
@@ -48,8 +46,8 @@ export class PHPIncluseResolver {
     const imports: PHPImports = {
       resolved: new Map(),
       unresolved: {
-        paths: [],
-        namespaces: [],
+        paths: new Set(),
+        namespaces: new Set(),
       },
     };
     for (const use of useDirectives) {
@@ -78,7 +76,7 @@ export class PHPIncluseResolver {
           }
         }
       } else if (name) {
-        imports.unresolved.namespaces.push(name);
+        imports.unresolved.namespaces.add(name);
       }
     }
     return imports;
@@ -102,32 +100,50 @@ export class PHPIncluseResolver {
     return [...leftArr, ...rightArr];
   }
 
-  #resolveIncludeDirectives(file: PHPFile) {
+  #resolveIncludeDirectives(file: PHPFile, visitedFiles = new Set<string>()) {
     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: [],
+        paths: new Set(),
+        namespaces: new Set(),
       },
     };
+
+    // Add the current file to the visited set to prevent infinite recursion
+    visitedFiles.add(file.path);
+
     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) {
+        if (importedfile && !visitedFiles.has(importedfile.path)) {
           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);
+          const nestedImports = this.#resolveIncludeDirectives(
+            importedfile,
+            visitedFiles,
+          );
+          for (const [k, v] of nestedImports.resolved) {
+            if (imports.resolved.has(k)) {
+              imports.resolved.get(k)!.push(...v);
+            } else {
+              imports.resolved.set(k, v);
+            }
+          }
+          imports.unresolved.paths = imports.unresolved.paths.union(
+            nestedImports.unresolved.paths,
+          );
+        } else if (!importedfile) {
+          imports.unresolved.paths.add(path);
         }
       } else if (include.name === "includebin") {
         const fileparts = this.#splitBinary(include.node)
@@ -139,19 +155,34 @@ export class PHPIncluseResolver {
           filepath,
           file.path,
         );
-        if (importedfile) {
+        if (importedfile && !visitedFiles.has(importedfile.path)) {
           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);
+          const nestedImports = this.#resolveIncludeDirectives(
+            importedfile,
+            visitedFiles,
+          );
+          for (const [k, v] of nestedImports.resolved) {
+            if (imports.resolved.has(k)) {
+              imports.resolved.get(k)!.push(...v);
+            } else {
+              imports.resolved.set(k, v);
+            }
+          }
+          imports.unresolved.paths = imports.unresolved.paths.union(
+            nestedImports.unresolved.paths,
+          );
+        } else if (!importedfile) {
+          imports.unresolved.paths.add(filepath);
         }
       }
     }
+
     return imports;
   }
 }

src/languagePlugins/php/incluseResolver/types.ts

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