Support goto in new objects

Author: AJenbo

src/completion/resolver.rs

@@ -45,7 +45,7 @@ impl Backend {
     #[allow(clippy::too_many_arguments)]
     pub fn resolve_target_class(
         subject: &str,
-        access_kind: AccessKind,
+        _access_kind: AccessKind,
         current_class: Option<&ClassInfo>,
         all_classes: &[ClassInfo],
         content: &str,
@@ -74,8 +74,12 @@ impl Backend {
             return None;
         }
 
-        // ── Bare class name (for `::`) ──
-        if access_kind == AccessKind::DoubleColon && !subject.starts_with('$') {
+        // ── Bare class name (for `::` or `->` from `new ClassName()`) ──
+        if !subject.starts_with('$')
+            && !subject.contains("->")
+            && !subject.contains("::")
+            && !subject.ends_with("()")
+        {
             let lookup = subject.rsplit('\\').next().unwrap_or(subject);
             if let Some(cls) = all_classes.iter().find(|c| c.name == lookup) {
                 return Some(cls.clone());

src/completion/target.rs

@@ -7,7 +7,9 @@ use tower_lsp::lsp_types::*;
 
 use crate::Backend;
 use crate::types::*;
-use crate::util::skip_balanced_parens_back;
+use crate::util::{
+    check_new_keyword_before, extract_new_expression_inside_parens, skip_balanced_parens_back,
+};
 
 impl Backend {
     /// Detect the access operator before the cursor position and extract
@@ -68,6 +70,8 @@ impl Backend {
     ///   - `app()->` (function call)
     ///   - `$this->getService()->` (method call chain)
     ///   - `ClassName::make()->` (static method call)
+    ///   - `new ClassName()->` (instantiation, PHP 8.4+)
+    ///   - `(new ClassName())->` (parenthesized instantiation)
     fn extract_arrow_subject(chars: &[char], arrow_pos: usize) -> String {
         // Position just before the `->`
         let end = arrow_pos;
@@ -78,8 +82,9 @@ impl Backend {
             i -= 1;
         }
 
-        // ── Function / method call: detect `)` before the operator ──
-        // e.g. `app()->`, `$this->getService()->`, `Class::make()->`
+        // ── Function / method call or `new` expression: detect `)` ──
+        // e.g. `app()->`, `$this->getService()->`, `Class::make()->`,
+        //      `new Foo()->`, `(new Foo())->`
         if i > 0
             && chars[i - 1] == ')'
             && let Some(call_subject) = Self::extract_call_subject(chars, i)
@@ -128,6 +133,7 @@ impl Backend {
     ///   - `"app()"` for a standalone function call
     ///   - `"$this->getService()"` for an instance method call
     ///   - `"ClassName::make()"` for a static method call
+    ///   - `"ClassName"` for `new ClassName()` instantiation
     fn extract_call_subject(chars: &[char], paren_end: usize) -> Option<String> {
         let open = skip_balanced_parens_back(chars, paren_end)?;
         if open == 0 {
@@ -136,15 +142,24 @@ impl Backend {
 
         // Read the function / method name before `(`
         let mut i = open;
-        while i > 0 && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_') {
+        while i > 0
+            && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_' || chars[i - 1] == '\\')
+        {
             i -= 1;
         }
         if i == open {
-            // No identifier before `(` — can't resolve
-            return None;
+            // No identifier before `(` — check if the contents inside the
+            // balanced parens form a `(new ClassName(...))` expression.
+            return extract_new_expression_inside_parens(chars, open, paren_end);
         }
         let func_name: String = chars[i..open].iter().collect();
 
+        // ── `new ClassName()` instantiation ──
+        // Check if the `new` keyword immediately precedes the class name.
+        if let Some(class_name) = check_new_keyword_before(chars, i, &func_name) {
+            return Some(class_name);
+        }
+
         // Check what precedes the function name to determine the kind of
         // call expression.
 

src/definition/resolve.rs

@@ -20,7 +20,9 @@ use tower_lsp::lsp_types::*;
 use crate::Backend;
 use crate::composer;
 use crate::types::*;
-use crate::util::skip_balanced_parens_back;
+use crate::util::{
+    check_new_keyword_before, extract_new_expression_inside_parens, skip_balanced_parens_back,
+};
 
 /// The kind of class member being resolved.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -450,8 +452,9 @@ impl Backend {
             i -= 1;
         }
 
-        // ── Function / method call: detect `)` before the operator ──
-        // e.g. `app()->`, `$this->getService()->`, `Class::make()->`
+        // ── Function / method call or `new` expression: detect `)` ──
+        // e.g. `app()->`, `$this->getService()->`, `Class::make()->`,
+        //      `new Foo()->`, `(new Foo())->`
         if i > 0
             && chars[i - 1] == ')'
             && let Some(call_subject) = Self::extract_call_subject_for_definition(chars, i)
@@ -497,6 +500,7 @@ impl Backend {
     ///   - `"app()"` for a standalone function call
     ///   - `"$this->getService()"` for an instance method call
     ///   - `"ClassName::make()"` for a static method call
+    ///   - `"ClassName"` for `new ClassName()` instantiation
     fn extract_call_subject_for_definition(chars: &[char], paren_end: usize) -> Option<String> {
         let open = skip_balanced_parens_back(chars, paren_end)?;
         if open == 0 {
@@ -505,14 +509,24 @@ impl Backend {
 
         // Read the function / method name before `(`
         let mut i = open;
-        while i > 0 && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_') {
+        while i > 0
+            && (chars[i - 1].is_alphanumeric() || chars[i - 1] == '_' || chars[i - 1] == '\\')
+        {
             i -= 1;
         }
         if i == open {
-            return None;
+            // No identifier before `(` — check if the contents inside the
+            // balanced parens form a `(new ClassName(...))` expression.
+            return extract_new_expression_inside_parens(chars, open, paren_end);
         }
         let func_name: String = chars[i..open].iter().collect();
 
+        // ── `new ClassName()` instantiation ──
+        // Check if the `new` keyword immediately precedes the class name.
+        if let Some(class_name) = check_new_keyword_before(chars, i, &func_name) {
+            return Some(class_name);
+        }
+
         // Instance method call: `$this->method()` / `$var->method()`
         if i >= 2 && chars[i - 2] == '-' && chars[i - 1] == '>' {
             let inner_subject = Self::extract_simple_var_before(chars, i - 2);

src/util.rs

@@ -39,6 +39,90 @@ pub(crate) fn skip_balanced_parens_back(chars: &[char], pos: usize) -> Option<us
     None
 }
 
+/// Check if the `new` keyword (followed by whitespace) appears immediately
+/// before the identifier starting at position `ident_start`.
+///
+/// Returns the class name (possibly with namespace) if `new` is found.
+pub(crate) fn check_new_keyword_before(
+    chars: &[char],
+    ident_start: usize,
+    class_name: &str,
+) -> Option<String> {
+    let mut j = ident_start;
+    // Skip whitespace between `new` and the class name.
+    while j > 0 && chars[j - 1] == ' ' {
+        j -= 1;
+    }
+    // Check for the `new` keyword.
+    if j >= 3 && chars[j - 3] == 'n' && chars[j - 2] == 'e' && chars[j - 1] == 'w' {
+        // Verify word boundary before `new` (start of line, whitespace, `(`, etc.).
+        let before_ok = j == 3 || {
+            let prev = chars[j - 4];
+            !prev.is_alphanumeric() && prev != '_'
+        };
+        if before_ok {
+            // Strip leading `\` from FQN if present.
+            let name = class_name.strip_prefix('\\').unwrap_or(class_name);
+            return Some(name.to_string());
+        }
+    }
+    None
+}
+
+/// Try to extract a class name from a parenthesized `new` expression:
+/// `(new ClassName(...))`.
+///
+/// `open` is the position of the outer `(`, `close` is one past the
+/// outer `)`.  The function looks inside for the pattern
+/// `new ClassName(...)`.
+pub(crate) fn extract_new_expression_inside_parens(
+    chars: &[char],
+    open: usize,
+    close: usize,
+) -> Option<String> {
+    // Content is chars[open+1 .. close-1].
+    let inner_start = open + 1;
+    let inner_end = close - 1;
+    if inner_start >= inner_end {
+        return None;
+    }
+
+    // Skip whitespace inside the opening `(`.
+    let mut k = inner_start;
+    while k < inner_end && chars[k] == ' ' {
+        k += 1;
+    }
+
+    // Check for `new` keyword.
+    if k + 3 >= inner_end {
+        return None;
+    }
+    if chars[k] != 'n' || chars[k + 1] != 'e' || chars[k + 2] != 'w' {
+        return None;
+    }
+    k += 3;
+
+    // Must be followed by whitespace.
+    if k >= inner_end || chars[k] != ' ' {
+        return None;
+    }
+    while k < inner_end && chars[k] == ' ' {
+        k += 1;
+    }
+
+    // Read the class name (may include `\` for namespaces).
+    let name_start = k;
+    while k < inner_end && (chars[k].is_alphanumeric() || chars[k] == '_' || chars[k] == '\\') {
+        k += 1;
+    }
+    if k == name_start {
+        return None;
+    }
+    let class_name: String = chars[name_start..k].iter().collect();
+    let name = class_name.strip_prefix('\\').unwrap_or(&class_name);
+    Some(name.to_string())
+}
+
 impl Backend {
     /// Convert an LSP Position (line, character) to a byte offset in content.
     pub(crate) fn position_to_offset(content: &str, position: Position) -> Option<u32> {