String-aware completion suppression

Author: AJenbo

docs/CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Anonymous class completion and go-to-definition.** `$this->` inside anonymous class bodies (`new class { ... }`) now resolves to the anonymous class's own members, properties, and constants. Supports `extends`, `implements`, trait `use`, constructor-promoted properties, and `@var` docblock types. Anonymous classes nested inside named class methods, closures, control flow blocks, function arguments, and return statements are all detected. `find_class_at_offset` now picks the innermost (most specific) class when scopes overlap.
 - **Alphabetical `use` statement insertion.** Auto-imported `use` statements are now inserted at the correct alphabetical position among existing imports instead of being appended at the bottom of the use block. This keeps the import list sorted, matching the convention expected by PSR-12, Symfony, and Laravel coding standards.
 - **Namespace segment completion.** When typing a namespace-qualified reference (`use App\`, `new \Illuminate\`, `\App\` in a type hint, etc.), completion now shows the next-level namespace segments as navigable MODULE-kind items alongside matching classes. Segments sort above class items so the user can drill into deep namespace trees incrementally instead of being overwhelmed by hundreds of flat class names. Works in `use` statements, `new` expressions, type hints, docblocks, `instanceof`, `extends`, `implements`, and trait `use` contexts. Segments respect the typed partial (e.g. `App\M` shows `App\Models` but not `App\Services`), simplify within the current namespace, and carry correct leading-backslash handling. In `use` import context, segments do not receive a trailing semicolon.
+- **String-aware completion suppression.** Completion is now suppressed inside string literals (single-quoted strings, nowdocs, and plain text in double-quoted strings and heredocs) to reduce noise from accidental triggers. Interpolation contexts are detected and allowed through: `{$expr->}` brace interpolation and simple `"$var->"` property access both produce completions as expected. Array shape key completion (`$arr['`) is unaffected.
 
 ### Fixed
 

docs/todo.md

@@ -30,20 +30,45 @@ target.
 
 ### Remaining by user need
 
-#### 27. No completion inside string interpolation
+#### 39. `@var` type annotation without variable name not resolved
 
-Inside double-quoted strings with variable interpolation, member access
-completion does not work. PHP supports `"Hello $user->name"` and
-`"Hello {$user->getName()}"`, but the completion handler has no
-string-interpolation awareness. The subject extraction may accidentally
-work in trivial cases but is not reliable because the surrounding quote
-characters can confuse offset calculation and the patched content.
+When a `@var` docblock includes the variable name, the type is picked up
+correctly. When the variable name is omitted (a common shorthand), the
+type is not applied to the next assignment.
 
 ```php
-$greeting = "Hello {$user->}";
-//                         ^ no completion
+// Works:
+/** @var User $red */
+$red = a();
+$red->  // ← completes User members
+
+// Does not work:
+/** @var User */
+$red = a();
+$red->  // ← no completion
 ```
 
+**Fix:** when `@var` has a type but no variable name, apply the type to
+the immediately following assignment statement.
+
+---
+
+#### 40. No nested key completion for literal array assignments
+
+When a variable is assigned a literal array with nested associative
+keys, completing the second-level key after `$arr['first']['` does not
+offer suggestions. It works when an `array{...}` shape docblock is
+present, but not for arrays inferred purely from the literal.
+
+```php
+$red = ['a' => ['b' => 1, 'c' => 2]];
+$red['a']['  // ← no completion for 'b' / 'c'
+```
+
+**Fix:** extend the array-shape inference in `array_shape.rs` to
+recursively extract nested literal array structures so that multi-level
+key completion works without a docblock annotation.
+
 ---
 
 #### 34 / 36. No go-to-definition for built-in (stub) functions and constants

example.php

@@ -58,6 +58,18 @@
 $user->output;               // @property-read (Renderable interface)
 $user->render();             // @method (Renderable interface)
 
+
+// ── String Interpolation ────────────────────────────────────────────────────
+// Completion is suppressed inside plain string content but still works in
+// PHP interpolation contexts. Try: delete the property name after -> and
+// trigger completion to see members offered.
+
+$greeting = "Hello {$user->getProfile()->bio}";   // brace interpolation — completion works
+$info = "Name: $user->displayName";               // simple interpolation — completion works
+$nope = 'no $user-> here';                        // single-quoted — completion suppressed
+$plain = "just plain text";                       // no $ — completion suppressed
+
+
 // ── Parenthesized RHS Assignment ─────────────────────────────────────────────
 // Try completion after -> on $parenUser, which is assigned from a parenthesized expression.
 

src/completion/comment_position.rs

@@ -1,10 +1,10 @@
-//! Comment and docblock position detection.
+//! Comment, docblock, and string position detection.
 //!
 //! This module provides utilities to determine whether a given cursor
-//! position falls inside a comment or docblock.  These are used early in
-//! the completion pipeline to decide whether to suppress normal
-//! completions (inside `//` / `/* */`) or to switch to PHPDoc tag
-//! completion (inside `/** */`).
+//! position falls inside a comment, docblock, or string literal.  These
+//! are used early in the completion pipeline to decide whether to suppress
+//! normal completions (inside `//` / `/* */` / string literals) or to
+//! switch to PHPDoc tag completion (inside `/** */`).
 //!
 //! The functions here are pure — they take `(content, Position)` and
 //! return a result without any shared state.
@@ -201,3 +201,293 @@ pub fn is_inside_non_doc_comment(content: &str, position: Position) -> bool {
     // Cursor is at or past end of file
     state == State::LineComment || state == State::BlockComment
 }
+
+/// Classification of the string context at a given cursor position.
+#[derive(Debug, PartialEq, Eq)]
+pub enum StringContext {
+    /// The cursor is not inside any string literal.
+    NotInString,
+    /// The cursor is inside a string literal where interpolation is not
+    /// possible (single-quoted string, nowdoc) or where the cursor is at
+    /// a position that is not an interpolation site (plain text inside a
+    /// double-quoted string or heredoc). Completion should be suppressed.
+    InStringLiteral,
+    /// The cursor is inside a simple interpolation context without braces
+    /// (`"$var->"`, `"$var"`). PHP only allows property access here (no
+    /// method calls, no chaining), so completion should filter to
+    /// properties only.
+    SimpleInterpolation,
+    /// The cursor is inside a `{$…}` brace interpolation context where
+    /// full PHP expressions are allowed (`"{$user->getName()}"`).
+    /// Completion should proceed normally with no filtering.
+    BraceInterpolation,
+}
+
+/// Classifies whether the cursor is inside a string and, if so, whether
+/// it is at an interpolation site where completion should still fire.
+///
+/// Returns [`StringContext::InStringLiteral`] when completion should be
+/// suppressed, [`StringContext::InInterpolation`] when inside a PHP
+/// interpolation expression, and [`StringContext::NotInString`] when the
+/// cursor is in normal code.
+pub fn classify_string_context(content: &str, position: Position) -> StringContext {
+    let target = position_to_byte_offset(content, position);
+    let bytes = content.as_bytes();
+    let len = bytes.len();
+    let mut i = 0;
+
+    #[derive(PartialEq, Clone, Copy)]
+    enum State {
+        Code,
+        SingleString,
+        DoubleString,
+        LineComment,
+        BlockComment,
+        Docblock,
+        Heredoc,
+        Nowdoc,
+    }
+
+    let mut state = State::Code;
+    let mut heredoc_label: Vec<u8> = Vec::new();
+    // Brace depth for `{$...}` interpolation inside double-quoted strings
+    // and heredocs. Zero means we are in the string body proper; > 0 means
+    // we are inside a `{$…}` complex interpolation expression.
+    let mut brace_depth: u32 = 0;
+
+    while i < len {
+        if i >= target {
+            return match state {
+                State::SingleString | State::Nowdoc => StringContext::InStringLiteral,
+                State::DoubleString | State::Heredoc => {
+                    if brace_depth > 0 {
+                        StringContext::BraceInterpolation
+                    } else if is_simple_interpolation_site(bytes, target) {
+                        StringContext::SimpleInterpolation
+                    } else {
+                        StringContext::InStringLiteral
+                    }
+                }
+                _ => StringContext::NotInString,
+            };
+        }
+
+        match state {
+            State::Code => {
+                if bytes[i] == b'/' && i + 1 < len && bytes[i + 1] == b'/' {
+                    state = State::LineComment;
+                    i += 2;
+                } else if bytes[i] == b'/'
+                    && i + 2 < len
+                    && bytes[i + 1] == b'*'
+                    && bytes[i + 2] == b'*'
+                    && (i + 3 >= len || bytes[i + 3] != b'*')
+                {
+                    state = State::Docblock;
+                    i += 3;
+                } else if bytes[i] == b'/' && i + 1 < len && bytes[i + 1] == b'*' {
+                    state = State::BlockComment;
+                    i += 2;
+                } else if bytes[i] == b'\'' {
+                    state = State::SingleString;
+                    i += 1;
+                } else if bytes[i] == b'"' {
+                    state = State::DoubleString;
+                    brace_depth = 0;
+                    i += 1;
+                } else if bytes[i] == b'<'
+                    && i + 2 < len
+                    && bytes[i + 1] == b'<'
+                    && bytes[i + 2] == b'<'
+                {
+                    i += 3;
+                    while i < len && bytes[i] == b' ' {
+                        i += 1;
+                    }
+                    let is_nowdoc = i < len && bytes[i] == b'\'';
+                    if is_nowdoc {
+                        i += 1;
+                    }
+                    heredoc_label.clear();
+                    while i < len && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
+                        heredoc_label.push(bytes[i]);
+                        i += 1;
+                    }
+                    if !heredoc_label.is_empty() {
+                        if is_nowdoc {
+                            if i < len && bytes[i] == b'\'' {
+                                i += 1;
+                            }
+                            state = State::Nowdoc;
+                        } else {
+                            state = State::Heredoc;
+                            brace_depth = 0;
+                        }
+                    }
+                } else {
+                    i += 1;
+                }
+            }
+            State::LineComment => {
+                if bytes[i] == b'\n' {
+                    state = State::Code;
+                }
+                i += 1;
+            }
+            State::BlockComment | State::Docblock => {
+                if bytes[i] == b'*' && i + 1 < len && bytes[i + 1] == b'/' {
+                    state = State::Code;
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+            State::SingleString => {
+                if bytes[i] == b'\\' && i + 1 < len {
+                    i += 2;
+                } else if bytes[i] == b'\'' {
+                    state = State::Code;
+                    i += 1;
+                } else {
+                    i += 1;
+                }
+            }
+            State::DoubleString => {
+                if bytes[i] == b'\\' && i + 1 < len {
+                    i += 2;
+                } else if bytes[i] == b'"' && brace_depth == 0 {
+                    state = State::Code;
+                    i += 1;
+                } else if bytes[i] == b'{'
+                    && ((i + 1 < len && bytes[i + 1] == b'$') || brace_depth > 0)
+                {
+                    brace_depth += 1;
+                    i += 1;
+                } else if bytes[i] == b'}' && brace_depth > 0 {
+                    brace_depth -= 1;
+                    i += 1;
+                } else {
+                    i += 1;
+                }
+            }
+            State::Heredoc => {
+                if bytes[i] == b'{' && ((i + 1 < len && bytes[i + 1] == b'$') || brace_depth > 0) {
+                    brace_depth += 1;
+                    i += 1;
+                } else if bytes[i] == b'}' && brace_depth > 0 {
+                    brace_depth -= 1;
+                    i += 1;
+                } else if bytes[i] == b'\n' {
+                    i += 1;
+                    let line_start = i;
+                    while i < len && (bytes[i] == b' ' || bytes[i] == b'\t') {
+                        i += 1;
+                    }
+                    if i + heredoc_label.len() <= len
+                        && &bytes[i..i + heredoc_label.len()] == heredoc_label.as_slice()
+                    {
+                        let after_label = i + heredoc_label.len();
+                        if after_label >= len
+                            || bytes[after_label] == b';'
+                            || bytes[after_label] == b'\n'
+                            || bytes[after_label] == b'\r'
+                        {
+                            i = after_label;
+                            state = State::Code;
+                            brace_depth = 0;
+                            continue;
+                        }
+                    }
+                    let _ = line_start;
+                } else {
+                    i += 1;
+                }
+            }
+            State::Nowdoc => {
+                if bytes[i] == b'\n' {
+                    i += 1;
+                    let line_start = i;
+                    while i < len && (bytes[i] == b' ' || bytes[i] == b'\t') {
+                        i += 1;
+                    }
+                    if i + heredoc_label.len() <= len
+                        && &bytes[i..i + heredoc_label.len()] == heredoc_label.as_slice()
+                    {
+                        let after_label = i + heredoc_label.len();
+                        if after_label >= len
+                            || bytes[after_label] == b';'
+                            || bytes[after_label] == b'\n'
+                            || bytes[after_label] == b'\r'
+                        {
+                            i = after_label;
+                            state = State::Code;
+                            continue;
+                        }
+                    }
+                    let _ = line_start;
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    // Cursor at or past end of file
+    match state {
+        State::SingleString | State::Nowdoc => StringContext::InStringLiteral,
+        State::DoubleString | State::Heredoc => {
+            if brace_depth > 0 {
+                StringContext::BraceInterpolation
+            } else if is_simple_interpolation_site(bytes, target) {
+                StringContext::SimpleInterpolation
+            } else {
+                StringContext::InStringLiteral
+            }
+        }
+        _ => StringContext::NotInString,
+    }
+}
+
+/// Checks whether the bytes immediately before `target` look like a PHP
+/// interpolation site inside a double-quoted string or heredoc.
+///
+/// Recognised patterns (cursor shown as `|`):
+/// - `$identifier->|`  or `$identifier?->|` — member access
+/// - `$identifier|` — partially typed variable name
+/// - `$|` — bare dollar, user is starting an interpolation
+///
+/// All of these are valid interpolation starts in PHP double-quoted
+/// strings, so completion should be allowed rather than suppressed.
+fn is_simple_interpolation_site(bytes: &[u8], target: usize) -> bool {
+    let mut pos = target;
+
+    // ── Case 1: member access `$identifier->` / `$identifier?->` ────
+    // Check `?->` first so the longer operator is not partially matched.
+    let has_arrow =
+        if pos >= 3 && bytes[pos - 3] == b'?' && bytes[pos - 2] == b'-' && bytes[pos - 1] == b'>' {
+            pos -= 3;
+            true
+        } else if pos >= 2 && bytes[pos - 2] == b'-' && bytes[pos - 1] == b'>' {
+            pos -= 2;
+            true
+        } else {
+            false
+        };
+
+    // Walk back over the identifier `[a-zA-Z0-9_]*`.
+    let before_ident = pos;
+    while pos > 0 && (bytes[pos - 1].is_ascii_alphanumeric() || bytes[pos - 1] == b'_') {
+        pos -= 1;
+    }
+    let ident_len = before_ident - pos;
+
+    // If we consumed an arrow, the identifier must be non-empty and
+    // preceded by `$`.
+    if has_arrow {
+        return ident_len > 0 && pos > 0 && bytes[pos - 1] == b'$';
+    }
+
+    // ── Case 2: bare `$` or `$partialName` (variable interpolation) ─
+    // The identifier may be empty (just `$`) or partially typed.
+    pos > 0 && bytes[pos - 1] == b'$'
+}