fix: complete chains after same-line closure close

Recognize lines like `})->` as continuations when completing member
access after a multi-line closure argument. This lets the resolver rebuild
the full receiver instead of returning no suggestions until the chain
operator is moved to a fresh line.

Closes #282

Author: calebdw

docs/CHANGELOG.md

@@ -44,6 +44,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Completion works after closing a multi-line closure argument on the same line as the next chain operator.** Typing `->` immediately after a call like `->map(function (...) { ... })->` now resolves the full receiver instead of returning no member suggestions until the operator is moved to a new line. Contributed by @calebdw.
 - **Deprecated enum cases are recognized.** Enum cases annotated with `@deprecated` or `#[Deprecated]` now carry deprecation metadata, so usages like `self::Low` can be highlighted as deprecated in contextual semantic-token mode. Contributed by @calebdw.
 - **Class constant accesses use constant semantic highlighting.** `self::CONSTANT`, `static::CONSTANT`, `parent::CONSTANT`, and `ClassName::CONSTANT` now emit the `enumMember` semantic token instead of being colored as properties, while `ClassName::$property` still emits `property`. Contributed by @calebdw.
 - **PHP attributes use decorator semantic highlighting.** Attribute class names in `#[...]` now emit the `decorator` semantic token instead of `class`, so editor themes can color attributes differently from normal class references. Contributed by @calebdw.

src/text_scan.rs

@@ -271,10 +271,11 @@ pub(crate) fn find_matching_backward(
 /// Collapse multi-line method chains around the cursor into a single line.
 ///
 /// When the cursor line (after trimming leading whitespace) begins with
-/// `->` or `?->`, this function walks backwards through preceding lines
-/// that are also continuations, plus the base expression line, and joins
-/// them into one flattened string.  The returned column is the cursor's
-/// position within that flattened string.
+/// `->` or `?->`, or closes a multi-line argument immediately before one
+/// of those operators, this function walks backwards through preceding
+/// lines that are also continuations, plus the base expression line, and
+/// joins them into one flattened string.  The returned column is the
+/// cursor's position within that flattened string.
 ///
 /// If the cursor line is not a continuation, the original line and column
 /// are returned unchanged.
@@ -290,10 +291,15 @@ pub(crate) fn collapse_continuation_lines(
 ) -> (String, usize) {
     let line = lines[cursor_line];
     let trimmed = line.trim_start();
+    let same_line_continuation_prefix = same_line_continuation_prefix(trimmed);
 
-    // Only collapse when the cursor line is a continuation (starts with
-    // `->` or `?->` after optional whitespace).
-    if !trimmed.starts_with("->") && !trimmed.starts_with("?->") {
+    // Only collapse when the cursor line is a continuation. Besides the
+    // direct form (`->foo`), this includes lines like `})->foo` where the
+    // cursor is continuing a call whose closure argument ended on this line.
+    if !trimmed.starts_with("->")
+        && !trimmed.starts_with("?->")
+        && same_line_continuation_prefix.is_none()
+    {
         return (line.to_string(), cursor_col);
     }
 
@@ -336,7 +342,8 @@ pub(crate) fn collapse_continuation_lines(
             start -= 1;
 
             // Count paren/brace balance from `start` up to (but not
-            // including) the cursor line.
+            // including) the cursor line. For same-line continuations
+            // like `})->foo`, include the closers before the operator.
             let mut paren_depth: i32 = 0;
             let mut brace_depth: i32 = 0;
             for line in lines.iter().take(cursor_line).skip(start) {
@@ -350,6 +357,17 @@ pub(crate) fn collapse_continuation_lines(
                     }
                 }
             }
+            if let Some(prefix) = same_line_continuation_prefix {
+                for ch in prefix.chars() {
+                    match ch {
+                        '(' => paren_depth += 1,
+                        ')' => paren_depth -= 1,
+                        '{' => brace_depth += 1,
+                        '}' => brace_depth -= 1,
+                        _ => {}
+                    }
+                }
+            }
 
             // If balanced (or net-open), this is a proper base line.
             if paren_depth >= 0 && brace_depth >= 0 {
@@ -408,3 +426,28 @@ pub(crate) fn collapse_continuation_lines(
 
     (prefix, new_col)
 }
+
+fn same_line_continuation_prefix(trimmed: &str) -> Option<&str> {
+    let mut end = 0;
+    let mut saw_closer = false;
+    for (idx, ch) in trimmed.char_indices() {
+        match ch {
+            ')' | '}' | ']' => {
+                saw_closer = true;
+                end = idx + ch.len_utf8();
+            }
+            ' ' | '\t' if saw_closer => {
+                end = idx + ch.len_utf8();
+            }
+            '-' | '?' if saw_closer => {
+                let rest = &trimmed[idx..];
+                if rest.starts_with("->") || rest.starts_with("?->") {
+                    return Some(&trimmed[..end]);
+                }
+                return None;
+            }
+            _ => return None,
+        }
+    }
+    None
+}

tests/integration/completion_multiline_chains.rs

@@ -531,3 +531,31 @@ async fn test_multiline_chain_with_closure_arg() {
         "Should offer Collection::filter() after chain with closure args, got: {names:?}"
     );
 }
+
+#[tokio::test]
+async fn test_multiline_chain_same_line_after_closure_arg_close() {
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///multiline_closure_same_line.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class Collection {\n",
+        "    public function map(callable $fn): static { return $this; }\n",
+        "    public function all(): array { return []; }\n",
+        "}\n",
+        "class Processor {\n",
+        "    public function items(): Collection { return new Collection(); }\n",
+        "    public function run(): void {\n",
+        "        $this->items()\n",
+        "            ->map(function ($x) {\n",
+        "                return $x;\n",
+        "            })->a\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let names = complete_at(&backend, &uri, text, 11, 17).await;
+    assert!(
+        names.iter().any(|n| n.starts_with("all(")),
+        "Should offer Collection::all() after same-line closure close, got: {names:?}"
+    );
+}