Add support for require_once

Author: AJenbo

src/composer.rs

@@ -416,3 +416,65 @@ fn is_builtin_type(name: &str) -> bool {
             | "iterable"
     )
 }
+
+/// Extract file paths from `require_once` statements in PHP source content.
+///
+/// Handles both the statement form and the function-like form:
+/// ```text
+///     require_once 'Trustly/exceptions.php';
+///     require_once('Trustly/Data/data.php');
+/// ```
+///
+/// Only bare string literals are supported — concatenations, variables,
+/// and other dynamic expressions are silently skipped.
+///
+/// Returns the raw path strings exactly as written in the source (e.g.
+/// `"Trustly/exceptions.php"`).  The caller is responsible for resolving
+/// them relative to the file's directory.
+pub fn extract_require_once_paths(content: &str) -> Vec<String> {
+    let mut paths = Vec::new();
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+
+        // Quick reject: line must start with `require_once`.
+        // (We don't support `require_once` buried in complex expressions.)
+        if !trimmed.starts_with("require_once") {
+            continue;
+        }
+
+        let rest = trimmed["require_once".len()..].trim_start();
+
+        // Strip optional parentheses: `require_once('...')` → `'...'`
+        // Also handles `require_once '...'` without parens.
+        let rest = if let Some(inner) = rest.strip_prefix('(') {
+            // Find matching closing paren
+            if let Some(end) = inner.rfind(')') {
+                inner[..end].trim()
+            } else {
+                continue;
+            }
+        } else {
+            rest
+        };
+
+        // Strip trailing semicolon
+        let rest = rest.trim_end_matches(';').trim();
+
+        // Extract string literal — single or double quoted
+        let path = if (rest.starts_with('\'') && rest.ends_with('\''))
+            || (rest.starts_with('"') && rest.ends_with('"'))
+        {
+            &rest[1..rest.len() - 1]
+        } else {
+            // Not a simple string literal — skip
+            continue;
+        };
+
+        if !path.is_empty() {
+            paths.push(path.to_string());
+        }
+    }
+
+    paths
+}

src/server.rs

@@ -3,7 +3,8 @@
 /// This module contains the `impl LanguageServer for Backend` block,
 /// which handles all LSP protocol messages (initialize, didOpen, didChange,
 /// didClose, completion, etc.).
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
 
 use tower_lsp::LanguageServer;
 use tower_lsp::jsonrpc::Result;
@@ -97,13 +98,27 @@ impl LanguageServer for Backend {
             }
 
             // Parse autoload_files.php to discover global function definitions.
+            // Also follow `require_once` statements in those files to discover
+            // additional classes and functions (used by packages like Trustly
+            // that don't follow composer conventions).
             let autoload_files = composer::parse_autoload_files(&root, &vendor_dir);
             let autoload_count = autoload_files.len();
 
-            for file_path in &autoload_files {
-                if let Ok(content) = std::fs::read_to_string(file_path) {
+            // Work queue + visited set for following require_once chains.
+            let mut file_queue: Vec<PathBuf> = autoload_files;
+            let mut visited: HashSet<PathBuf> = HashSet::new();
+
+            while let Some(file_path) = file_queue.pop() {
+                // Canonicalise to avoid revisiting the same file via
+                // different relative paths.
+                let canonical = file_path.canonicalize().unwrap_or(file_path);
+                if !visited.insert(canonical.clone()) {
+                    continue;
+                }
+
+                if let Ok(content) = std::fs::read_to_string(&canonical) {
                     let functions = self.parse_functions(&content);
-                    let uri = format!("file://{}", file_path.display());
+                    let uri = format!("file://{}", canonical.display());
 
                     if let Ok(mut fmap) = self.global_functions.lock() {
                         for func in functions {
@@ -127,6 +142,17 @@ impl LanguageServer for Backend {
                     // Also cache classes from these files in the ast_map so
                     // that class definitions in autoload files are available.
                     self.update_ast(&uri, &content);
+
+                    // Follow require_once statements to discover more files.
+                    let require_paths = composer::extract_require_once_paths(&content);
+                    if let Some(file_dir) = canonical.parent() {
+                        for rel_path in require_paths {
+                            let resolved = file_dir.join(&rel_path);
+                            if resolved.is_file() {
+                                file_queue.push(resolved);
+                            }
+                        }
+                    }
                 }
             }
 

tests/composer.rs

@@ -1,6 +1,6 @@
 use phpantom_lsp::composer::{
-    normalise_path, parse_autoload_classmap, parse_autoload_files, parse_composer_json,
-    parse_vendor_autoload_psr4, resolve_class_path,
+    extract_require_once_paths, normalise_path, parse_autoload_classmap, parse_autoload_files,
+    parse_composer_json, parse_vendor_autoload_psr4, resolve_class_path,
 };
 use std::fs;
 use std::path::Path;
@@ -714,6 +714,121 @@ fn test_autoload_files_mixed_vendor_and_basedir() {
     }
 }
 
+// ─── extract_require_once_paths Tests ───────────────────────────────────────
+
+#[test]
+fn test_require_once_statement_form() {
+    let content = concat!(
+        "<?php\n",
+        "require_once 'Trustly/exceptions.php';\n",
+        "require_once 'Trustly/Data/data.php';\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(paths.len(), 2);
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+    assert_eq!(paths[1], "Trustly/Data/data.php");
+}
+
+#[test]
+fn test_require_once_function_form() {
+    let content = concat!(
+        "<?php\n",
+        "require_once('Trustly/exceptions.php');\n",
+        "require_once('Trustly/Data/data.php');\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(paths.len(), 2);
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+    assert_eq!(paths[1], "Trustly/Data/data.php");
+}
+
+#[test]
+fn test_require_once_double_quotes() {
+    let content = concat!(
+        "<?php\n",
+        "require_once \"Trustly/exceptions.php\";\n",
+        "require_once(\"Trustly/Data/data.php\");\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(paths.len(), 2);
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+    assert_eq!(paths[1], "Trustly/Data/data.php");
+}
+
+#[test]
+fn test_require_once_mixed_forms() {
+    let content = concat!(
+        "<?php\n",
+        "/**\n",
+        " * Main include file for working with the trustly-client-php code.\n",
+        " */\n",
+        "\n",
+        "require_once('Trustly/exceptions.php');\n",
+        "require_once('Trustly/Data/data.php');\n",
+        "require_once 'Trustly/Api/api.php';\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(paths.len(), 3);
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+    assert_eq!(paths[1], "Trustly/Data/data.php");
+    assert_eq!(paths[2], "Trustly/Api/api.php");
+}
+
+#[test]
+fn test_require_once_skips_dynamic_expressions() {
+    let content = concat!(
+        "<?php\n",
+        "require_once __DIR__ . '/Trustly/exceptions.php';\n",
+        "require_once $path;\n",
+        "require_once 'Trustly/Data/data.php';\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(
+        paths.len(),
+        1,
+        "Should skip dynamic expressions and only find the string literal"
+    );
+    assert_eq!(paths[0], "Trustly/Data/data.php");
+}
+
+#[test]
+fn test_require_once_ignores_other_includes() {
+    let content = concat!(
+        "<?php\n",
+        "include 'config.php';\n",
+        "include_once 'helpers.php';\n",
+        "require 'bootstrap.php';\n",
+        "require_once 'Trustly/exceptions.php';\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(
+        paths.len(),
+        1,
+        "Should only extract require_once, not include/include_once/require"
+    );
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+}
+
+#[test]
+fn test_require_once_empty_file() {
+    let content = "<?php\n";
+    let paths = extract_require_once_paths(content);
+    assert!(paths.is_empty());
+}
+
+#[test]
+fn test_require_once_with_extra_whitespace() {
+    let content = concat!(
+        "<?php\n",
+        "  require_once  (  'Trustly/exceptions.php'  )  ;\n",
+        "    require_once   'Trustly/Data/data.php'  ;\n",
+    );
+    let paths = extract_require_once_paths(content);
+    assert_eq!(paths.len(), 2);
+    assert_eq!(paths[0], "Trustly/exceptions.php");
+    assert_eq!(paths[1], "Trustly/Data/data.php");
+}
+
 // ─── autoload_classmap.php tests ────────────────────────────────────────────
 
 #[test]