Implement goto function definition

Author: AJenbo

src/completion/resolver.rs

@@ -7,6 +7,7 @@ use tower_lsp::lsp_types::*;
 
 use crate::Backend;
 use crate::types::*;
+use crate::util::skip_balanced_parens_back;
 
 impl Backend {
     /// Detect the access operator before the cursor position and extract
@@ -62,7 +63,11 @@ impl Backend {
     /// `chars[arrow_pos]` = `-`, `chars[arrow_pos+1]` = `>`).
     ///
     /// Handles:
-    ///   `$this->`, `$var->`, `$this->prop->` (one level of chaining).
+    ///   - `$this->`, `$var->` (simple variable)
+    ///   - `$this->prop->` (property chain)
+    ///   - `app()->` (function call)
+    ///   - `$this->getService()->` (method call chain)
+    ///   - `ClassName::make()->` (static method call)
     fn extract_arrow_subject(chars: &[char], arrow_pos: usize) -> String {
         // Position just before the `->`
         let end = arrow_pos;
@@ -73,6 +78,15 @@ impl Backend {
             i -= 1;
         }
 
+        // ── Function / method call: detect `)` before the operator ──
+        // e.g. `app()->`, `$this->getService()->`, `Class::make()->`
+        if i > 0
+            && chars[i - 1] == ')'
+            && let Some(call_subject) = Self::extract_call_subject(chars, i)
+        {
+            return call_subject;
+        }
+
         // Try to read an identifier (property name if chained)
         let ident_end = i;
         while i > 0 && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_') {
@@ -105,6 +119,82 @@ impl Backend {
         Self::extract_simple_variable(chars, end)
     }
 
+    /// Extract the full call-expression subject when `)` appears before an
+    /// operator.
+    ///
+    /// `paren_end` is the position one past the closing `)`.
+    ///
+    /// Returns subjects such as:
+    ///   - `"app()"` for a standalone function call
+    ///   - `"$this->getService()"` for an instance method call
+    ///   - `"ClassName::make()"` for a static method call
+    fn extract_call_subject(chars: &[char], paren_end: usize) -> Option<String> {
+        let open = skip_balanced_parens_back(chars, paren_end)?;
+        if open == 0 {
+            return None;
+        }
+
+        // Read the function / method name before `(`
+        let mut i = open;
+        while i > 0 && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_') {
+            i -= 1;
+        }
+        if i == open {
+            // No identifier before `(` — can't resolve
+            return None;
+        }
+        let func_name: String = chars[i..open].iter().collect();
+
+        // Check what precedes the function name to determine the kind of
+        // call expression.
+
+        // Instance method call: `$this->method()` / `$var->method()`
+        if i >= 2 && chars[i - 2] == '-' && chars[i - 1] == '>' {
+            let inner_subject = Self::extract_simple_variable(chars, i - 2);
+            if !inner_subject.is_empty() {
+                return Some(format!("{}->{}()", inner_subject, func_name));
+            }
+        }
+
+        // Null-safe method call: `$var?->method()`
+        if i >= 3 && chars[i - 3] == '?' && chars[i - 2] == '-' && chars[i - 1] == '>' {
+            let inner_subject = Self::extract_simple_variable(chars, i - 3);
+            if !inner_subject.is_empty() {
+                return Some(format!("{}?->{}()", inner_subject, func_name));
+            }
+        }
+
+        // Static method call: `ClassName::method()` / `self::method()`
+        if i >= 2 && chars[i - 2] == ':' && chars[i - 1] == ':' {
+            let class_subject = Self::extract_double_colon_subject_raw(chars, i - 2);
+            if !class_subject.is_empty() {
+                return Some(format!("{}::{}()", class_subject, func_name));
+            }
+        }
+
+        // Standalone function call: `app()`
+        Some(format!("{}()", func_name))
+    }
+
+    /// Raw helper: extract identifier/keyword before `::` without going
+    /// through the public `extract_double_colon_subject` API.
+    fn extract_double_colon_subject_raw(chars: &[char], colon_pos: usize) -> String {
+        let mut i = colon_pos;
+        while i > 0 && chars[i - 1] == ' ' {
+            i -= 1;
+        }
+        let end = i;
+        while i > 0
+            && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_' || chars[i - 1] == '\\')
+        {
+            i -= 1;
+        }
+        if i > 0 && chars[i - 1] == '$' {
+            i -= 1;
+        }
+        chars[i..end].iter().collect()
+    }
+
     /// Extract a simple `$variable` ending at position `end` (exclusive).
     fn extract_simple_variable(chars: &[char], end: usize) -> String {
         let mut i = end;

src/completion/target.rs

@@ -5,6 +5,9 @@ use std::fs;
 /// mappings, and resolving fully-qualified PHP class names to file paths
 /// on disk using those mappings.
 ///
+/// It also parses `autoload_files.php` (generated by Composer) to discover
+/// files that contain global function and constant definitions.
+///
 /// # PSR-4 Resolution
 ///
 /// Given a mapping like `"Klarna\\" => "src/Klarna/"`, a class name like
@@ -43,6 +46,8 @@ pub fn parse_composer_json(workspace_root: &Path) -> Vec<Psr4Mapping> {
         Err(_) => return Vec::new(),
     };
 
+    let vendor_dir = get_vendor_dir(&json);
+
     let mut mappings = Vec::new();
 
     // Extract from both "autoload" and "autoload-dev" sections
@@ -58,7 +63,6 @@ pub fn parse_composer_json(workspace_root: &Path) -> Vec<Psr4Mapping> {
     }
 
     // Also load vendor autoload mappings (from composer install output)
-    let vendor_dir = get_vendor_dir(&json);
     let vendor_mappings = parse_vendor_autoload_psr4(workspace_root, &vendor_dir);
     mappings.extend(vendor_mappings);
 
@@ -177,6 +181,58 @@ fn resolve_autoload_path_entry(entry: &str, vendor_dir: &str) -> Option<String>
     }
 }
 
+/// Parse `<vendor>/composer/autoload_files.php` and return the resolved
+/// file paths.
+///
+/// This file is generated by `composer install` / `composer dump-autoload`
+/// and lists files that should be eagerly loaded — typically containing
+/// global function definitions, `define()` calls, and similar bootstrap
+/// code.
+///
+/// The file contains lines like:
+/// ```text
+///     'hash' => $vendorDir . '/org/pkg/src/functions.php',
+///     'hash' => $baseDir . '/app/Http/helpers.php',
+/// ```
+///
+/// `$vendorDir` is resolved relative to the workspace root using the
+/// configured vendor directory.  `$baseDir` is the workspace root itself.
+///
+/// Returns an empty `Vec` if the file does not exist or cannot be parsed.
+pub fn parse_autoload_files(workspace_root: &Path, vendor_dir: &str) -> Vec<PathBuf> {
+    let autoload_path = workspace_root
+        .join(vendor_dir)
+        .join("composer")
+        .join("autoload_files.php");
+
+    let content = match fs::read_to_string(&autoload_path) {
+        Ok(c) => c,
+        Err(_) => return Vec::new(),
+    };
+
+    let mut files = Vec::new();
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+
+        // Match lines of the form:  'hash' => $vendorDir . '/path/to/file.php',
+        //                       or: 'hash' => $baseDir . '/path/to/file.php',
+        // We look for `=> $vendorDir` or `=> $baseDir` after the hash key.
+        if let Some(arrow_pos) = trimmed.find("=> ") {
+            let rhs = trimmed[arrow_pos + 3..].trim().trim_end_matches(',');
+
+            if let Some(base_path) = resolve_autoload_path_entry(rhs, vendor_dir) {
+                let full_path = workspace_root.join(&base_path);
+                if full_path.is_file() {
+                    files.push(full_path);
+                }
+            }
+        }
+    }
+
+    files
+}
+
 /// Extract PSR-4 entries from a single prefix → path(s) pair.
 ///
 /// The value can be either a string (`"src/"`) or an array of strings