Fix template substitution for nested class-string<T> arguments

Author: AJenbo

src/completion/call_resolution.rs

@@ -1137,11 +1137,24 @@ impl Backend {
             let binding_mode = classify_template_binding(tpl_name, param_hint);
 
             match binding_mode {
-                TemplateBindingMode::Direct | TemplateBindingMode::GenericWrapper(..) => {
+                TemplateBindingMode::Direct => {
                     if let Some(resolved_type) = Self::resolve_arg_text_to_type(arg_text, ctx) {
                         subs.insert(tpl_name.clone(), resolved_type);
                     }
                 }
+                TemplateBindingMode::GenericWrapper(ref wrapper_name, tpl_position) => {
+                    if let Some(resolved_type) = Self::resolve_arg_text_to_type(arg_text, ctx) {
+                        // Special handling for class-string<T> to avoid double-wrapping
+                        if wrapper_name == "class-string"
+                            && tpl_position == 0
+                            && let Some(inner) = resolved_type.unwrap_class_string_inner()
+                        {
+                            subs.insert(tpl_name.clone(), inner.clone());
+                            continue;
+                        }
+                        subs.insert(tpl_name.clone(), resolved_type);
+                    }
+                }
                 TemplateBindingMode::CallableReturnType => {
                     // `@param callable(...): T $cb` — extract the closure's
                     // return type annotation from the argument text.

src/completion/types/conditional.rs

@@ -338,8 +338,7 @@ pub fn split_text_args(text: &str) -> Vec<&str> {
     let mut in_double_quote = false;
     let mut prev_was_backslash = false;
 
-    let mut chars = text.char_indices().peekable();
-    while let Some((i, ch)) = chars.next() {
+    for (i, ch) in text.char_indices() {
         if prev_was_backslash {
             prev_was_backslash = false;
             continue;

src/completion/variable/rhs_resolution.rs

@@ -1106,9 +1106,18 @@ pub(crate) fn build_function_template_subs(
                     subs.insert(tpl_name.clone(), concrete);
                     continue;
                 }
-                // Fall back to direct resolution for non-array wrappers
-                // or when raw type extraction fails.
-                if let Some(resolved_type) = Backend::resolve_arg_text_to_type(arg_text, rctx) {
+                // Special case: unwrap class-string<class-string<T>> to class-string<T>
+                if wrapper_name == "class-string" && tpl_position == 0 {
+                    if let Some(resolved_type) = Backend::resolve_arg_text_to_type(arg_text, rctx) {
+                        if let Some(inner) = resolved_type.unwrap_class_string_inner() {
+                            subs.insert(tpl_name.clone(), inner.clone());
+                        } else {
+                            subs.insert(tpl_name.clone(), resolved_type);
+                        }
+                    }
+                } else if let Some(resolved_type) =
+                    Backend::resolve_arg_text_to_type(arg_text, rctx)
+                {
                     subs.insert(tpl_name.clone(), resolved_type);
                 }
             }

src/php_type.rs

@@ -1521,6 +1521,14 @@ impl PhpType {
         }
     }
 
+    /// If this is a `class-string<T>`, returns `Some(&T)`. Otherwise, returns `None`.
+    pub fn unwrap_class_string_inner(&self) -> Option<&PhpType> {
+        match self {
+            PhpType::ClassString(Some(inner)) => Some(inner.as_ref()),
+            _ => None,
+        }
+    }
+
     /// Like [`all_members_scalar`] but uses the narrow
     /// [`is_primitive_scalar`] check.
     ///

tests/unit/conditional_split_args.rs

@@ -29,39 +29,19 @@ fn test_split_text_args_double_quoted_string_with_comma() {
 #[test]
 fn test_split_text_args_nested_quotes_and_escapes() {
     let args = split_text_args(r#""a,\"b,c\",d", 'x,\'y,z\'', foo)"#);
-    assert_eq!(
-        args,
-        vec![
-            r#""a,\"b,c\",d""#,
-            " 'x,\\'y,z\\''",
-            " foo)"
-        ]
-    );
+    assert_eq!(args, vec![r#""a,\"b,c\",d""#, " 'x,\\'y,z\\''", " foo)"]);
 }
 
 #[test]
 fn test_split_text_args_mixed_quotes_and_brackets() {
     let args = split_text_args(r#"array('a,b', ["x,y"]), "foo,bar""#);
-    assert_eq!(
-        args,
-        vec![
-            r#"array('a,b', ["x,y"])"#,
-            r#" "foo,bar""#
-        ]
-    );
+    assert_eq!(args, vec![r#"array('a,b', ["x,y"])"#, r#" "foo,bar""#]);
 }
 
 #[test]
 fn test_split_text_args_escaped_quotes() {
     let args = split_text_args(r#"'foo\,bar', "baz\"qux", plain"#);
-    assert_eq!(
-        args,
-        vec![
-            r#"'foo\,bar'"#,
-            r#" "baz\"qux""#,
-            " plain"
-        ]
-    );
+    assert_eq!(args, vec![r#"'foo\,bar'"#, r#" "baz\"qux""#, " plain"]);
 }
 
 #[test]
@@ -71,4 +51,4 @@ fn test_split_text_args_empty_and_whitespace() {
 
     let args = split_text_args("");
     assert_eq!(args, Vec::<&str>::new());
-}
+}

tests/unit/main.rs

@@ -1,6 +1,6 @@
 mod composer;
+mod conditional_split_args;
 mod docblock_parsing;
 mod monorepo;
 mod named_args_internals;
 mod phpdoc_internals;
-mod conditional_split_args;