Fix compleatino inside calls

Author: AJenbo

example.php

@@ -147,7 +147,7 @@ public function demo(): void
     {
         /** @var Pencil $inlineHinted */
         $inlineHinted = getUnknownValue();
-        $inlineHinted->sketch();                  // with explicit variable name
+        $inlineHinted->sketch();
 
         /** @var Pen */
         $hinted = getUnknownValue();

src/completion/handler.rs

@@ -38,14 +38,41 @@ use crate::Backend;
 use crate::completion::class_completion::{
     ClassCompletionParams, ClassNameContext, detect_class_name_context, is_class_declaration_name,
 };
-use crate::completion::named_args::{NamedArgContext, parse_existing_args};
+use crate::completion::named_args::{
+    NamedArgContext, cursor_inside_nested_bracket, parse_existing_args,
+};
 use crate::docblock::types::PHPDOC_TYPE_KEYWORDS;
 use crate::php_type::PhpType;
 use crate::symbol_map::SymbolKind;
 use crate::types::{ClassInfo, ResolvedType};
 use crate::types::{CompletionTarget, FileContext};
 use crate::util::{find_class_at_offset, position_to_byte_offset, position_to_offset};
 
+/// Append named-argument items into an existing [`CompletionResponse`].
+///
+/// If `named_arg_items` is empty the response is returned unchanged.
+/// Otherwise the items are appended to the response's item list,
+/// preserving the `is_incomplete` flag when the response is a
+/// [`CompletionList`].
+fn merge_named_args_into_response(
+    response: CompletionResponse,
+    named_arg_items: Vec<CompletionItem>,
+) -> CompletionResponse {
+    if named_arg_items.is_empty() {
+        return response;
+    }
+    match response {
+        CompletionResponse::Array(mut items) => {
+            items.extend(named_arg_items);
+            CompletionResponse::Array(items)
+        }
+        CompletionResponse::List(mut list) => {
+            list.items.extend(named_arg_items);
+            CompletionResponse::List(list)
+        }
+    }
+}
+
 /// Check whether a `(` immediately follows the cursor position (past any
 /// partial identifier the user has already typed).
 ///
@@ -296,10 +323,12 @@ impl Backend {
                 return Ok(self.complete_type_hint(&content, &th_ctx, &ctx, position, &uri));
             }
 
-            // ── Named argument completion ───────────────────────────
-            if let Some(response) = self.try_named_arg_completion(&uri, &content, position, &ctx) {
-                return Ok(Some(response));
-            }
+            // ── Named argument completion (collected, not short-circuited) ──
+            // Named arg items are always valid alongside normal
+            // completions, so collect them here and merge them into
+            // whatever strategy wins below.
+            let named_arg_items =
+                self.collect_named_arg_items(&uri, &content, position, &ctx);
 
             // ── String context detection ────────────────────────────
             // Classify once and use throughout the remaining pipeline.
@@ -368,7 +397,7 @@ impl Backend {
 
             // ── Smart catch clause completion ───────────────────────
             if let Some(response) = self.try_catch_completion(&content, position, &ctx, &uri) {
-                return Ok(Some(response));
+                return Ok(Some(merge_named_args_into_response(response, named_arg_items)));
             }
 
             // ── `throw new` completion ──────────────────────────────
@@ -388,7 +417,12 @@ impl Backend {
             if let Some(response) =
                 self.try_class_constant_function_completion(&content, position, &ctx, &uri)
             {
-                return Ok(Some(response));
+                return Ok(Some(merge_named_args_into_response(response, named_arg_items)));
+            }
+
+            // No strategy matched, but we may still have named arg items.
+            if !named_arg_items.is_empty() {
+                return Ok(Some(CompletionResponse::Array(named_arg_items)));
             }
         }
 
@@ -671,28 +705,33 @@ impl Backend {
 
     // ─── Strategy: named argument completion ─────────────────────────────
 
-    /// Try to offer `name:` argument completions inside function/method
+    /// Collect `name:` argument completion items inside function/method
     /// call parentheses.
     ///
-    /// Returns `None` when the cursor is not in a named-argument context
-    /// or when no parameters could be resolved.
-    fn try_named_arg_completion(
+    /// Returns an empty `Vec` when the cursor is not in a named-argument
+    /// context or when no parameters could be resolved.  The items are
+    /// meant to be **merged** into whatever other completion strategy
+    /// wins — named args are always valid alongside normal completions.
+    fn collect_named_arg_items(
         &self,
         uri: &str,
         content: &str,
         position: Position,
         ctx: &FileContext,
-    ) -> Option<CompletionResponse> {
+    ) -> Vec<CompletionItem> {
         // ── Primary path: AST-based detection via symbol map ────────
         // The symbol map's `CallSite` data handles chains, nesting,
         // and strings correctly.  Fall back to text scanning when the
         // AST has no hit (typically because the parser couldn't recover
         // from incomplete code).
-        let na_ctx = self
+        let na_ctx = match self
             .detect_named_arg_from_symbol_map(uri, content, position)
             .or_else(|| {
                 crate::completion::named_args::detect_named_arg_context(content, position)
-            })?;
+            }) {
+            Some(ctx) => ctx,
+            None => return Vec::new(),
+        };
 
         let mut params = self.resolve_named_arg_params(&na_ctx, content, position, ctx);
 
@@ -719,16 +758,7 @@ impl Backend {
             }
         }
 
-        if params.is_empty() {
-            return None;
-        }
-
-        let items = crate::completion::named_args::build_named_arg_completions(&na_ctx, &params);
-        if items.is_empty() {
-            None
-        } else {
-            Some(CompletionResponse::Array(items))
-        }
+        crate::completion::named_args::build_named_arg_completions(&na_ctx, &params)
     }
 
     /// Detect a named-argument context using precomputed [`CallSite`] data
@@ -749,6 +779,16 @@ impl Backend {
         let cursor_byte_offset = position_to_offset(content, position);
         let cs = symbol_map.find_enclosing_call_site(cursor_byte_offset)?;
 
+        // ── Bail out when cursor is inside a nested `[…]` or `{…}` ─
+        // If the cursor sits inside an array literal or braced
+        // expression that is itself an argument, named-arg completion
+        // for the outer call must not fire — the user wants normal
+        // value completion, not parameter names.
+        if cursor_inside_nested_bracket(content, cs.args_start as usize, cursor_byte_offset as usize)
+        {
+            return None;
+        }
+
         // ── Check eligibility at cursor ─────────────────────────────
         // Walk backward from cursor through identifier chars to find the
         // start of the current "word" in the raw source text.

src/completion/named_args.rs

@@ -20,6 +20,60 @@
 
 use tower_lsp::lsp_types::*;
 
+// ─── Shared helpers ─────────────────────────────────────────────────────────
+
+/// Check whether `cursor` (byte offset) sits inside a `[…]` or `{…}` pair
+/// that is nested within the call's argument span starting at `args_start`.
+///
+/// Scans forward from `args_start` to `cursor`, tracking bracket and brace
+/// depth while skipping string literals.  Returns `true` when the net depth
+/// is > 0, meaning the cursor is inside an array literal or braced
+/// expression — not at the top-level argument list of the call.
+pub fn cursor_inside_nested_bracket(content: &str, args_start: usize, cursor: usize) -> bool {
+    let bytes = content.as_bytes();
+    let end = cursor.min(bytes.len());
+    let mut i = args_start;
+    let mut bracket_depth: i32 = 0; // tracks [ ]
+    let mut brace_depth: i32 = 0; // tracks { }
+
+    while i < end {
+        match bytes[i] {
+            b'[' => bracket_depth += 1,
+            b']' => bracket_depth -= 1,
+            b'{' => brace_depth += 1,
+            b'}' => brace_depth -= 1,
+            // Skip single-quoted strings
+            b'\'' => {
+                i += 1;
+                while i < end {
+                    if bytes[i] == b'\\' {
+                        i += 1; // skip escaped char
+                    } else if bytes[i] == b'\'' {
+                        break;
+                    }
+                    i += 1;
+                }
+            }
+            // Skip double-quoted strings
+            b'"' => {
+                i += 1;
+                while i < end {
+                    if bytes[i] == b'\\' {
+                        i += 1; // skip escaped char
+                    } else if bytes[i] == b'"' {
+                        break;
+                    }
+                    i += 1;
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    bracket_depth > 0 || brace_depth > 0
+}
+
 // ─── Context ────────────────────────────────────────────────────────────────
 
 /// Information about a named-argument completion context.