Infer template params from default values in function and constructor

calls

Author: AJenbo

src/completion/call_resolution.rs

@@ -2008,23 +2008,29 @@ impl Backend {
             let arg_text = match arg_texts.get(param_idx) {
                 Some(text) => text.trim(),
                 None => {
-                    // No argument was provided at the call site.  If the
-                    // parameter has a default value of `null`, resolve the
-                    // template param to `null`.  This handles the common
-                    // pattern `@template TDefault` with
-                    // `@param TDefault $default = null` where the caller
-                    // omits the argument — e.g. `Collection::first()`
-                    // returns `TValue|TFirstDefault` and `TFirstDefault`
-                    // should become `null` when no default is passed.
+                    // No argument was provided at the call site.  Fall
+                    // back to the parameter's default value so that
+                    // template params can be inferred from defaults
+                    // (e.g. `app()` with `$name = Application::class`).
                     if let Some(param) = method.parameters.get(param_idx)
-                        && param.default_value.as_deref().is_some_and(|d| d == "null")
+                        && let Some(default) = param.default_value.as_deref()
                         && !subs.contains_key(tpl_name.as_str())
                     {
-                        crate::completion::variable::rhs_resolution::insert_or_union(
-                            &mut subs,
-                            tpl_name.to_string(),
-                            PhpType::null(),
-                        );
+                        if default == "null" {
+                            crate::completion::variable::rhs_resolution::insert_or_union(
+                                &mut subs,
+                                tpl_name.to_string(),
+                                PhpType::null(),
+                            );
+                        } else if let Some(resolved) =
+                            Backend::resolve_arg_text_to_type(default, ctx)
+                        {
+                            crate::completion::variable::rhs_resolution::insert_or_union(
+                                &mut subs,
+                                tpl_name.to_string(),
+                                resolved,
+                            );
+                        }
                     }
                     continue;
                 }

src/completion/variable/rhs_resolution.rs

@@ -1164,10 +1164,7 @@ fn build_constructor_template_subs(
         };
 
         // Get the corresponding argument text.
-        let arg_text = match arg_texts.get(param_idx) {
-            Some(text) => text.trim(),
-            None => continue,
-        };
+        let provided_arg = arg_texts.get(param_idx).map(|t| t.trim());
 
         // Determine the binding mode by inspecting the parameter's
         // docblock type hint.  The type hint tells us how the template
@@ -1178,6 +1175,27 @@ fn build_constructor_template_subs(
             .and_then(|p| p.type_hint.as_ref());
         let binding_mode = classify_template_binding(tpl_name, param_hint);
 
+        // Fall back to the parameter's default value only for binding
+        // modes where the default is meaningful.
+        let default_value = ctor
+            .parameters
+            .get(param_idx)
+            .and_then(|p| p.default_value.as_deref());
+        let arg_text: &str = match provided_arg {
+            Some(text) => text,
+            None => match &binding_mode {
+                TemplateBindingMode::ClassStringInner => match default_value {
+                    Some(d) => d,
+                    None => continue,
+                },
+                TemplateBindingMode::Direct => match default_value {
+                    Some(d) if d.ends_with("::class") => d,
+                    _ => continue,
+                },
+                _ => continue,
+            },
+        };
+
         match binding_mode {
             TemplateBindingMode::Direct => {
                 // `@param T $bar` — the argument resolves directly to T.
@@ -1856,10 +1874,7 @@ pub(crate) fn build_function_template_subs(
             None => continue,
         };
 
-        let arg_text = match arg_texts.get(param_idx) {
-            Some(text) => text.trim(),
-            None => continue,
-        };
+        let provided_arg = arg_texts.get(param_idx).map(|t| t.trim());
 
         // Determine the binding mode by inspecting the parameter's
         // docblock type hint.  The type hint tells us how the template
@@ -1870,6 +1885,28 @@ pub(crate) fn build_function_template_subs(
             .and_then(|p| p.type_hint.as_ref());
         let binding_mode = classify_template_binding(tpl_name, param_hint);
 
+        // Fall back to the parameter's default value only for binding
+        // modes where the default is meaningful (class-string<T> with
+        // a `Foo::class` default, or direct bindings with `::class`).
+        let default_value = func_info
+            .parameters
+            .get(param_idx)
+            .and_then(|p| p.default_value.as_deref());
+        let arg_text: &str = match provided_arg {
+            Some(text) => text,
+            None => match &binding_mode {
+                TemplateBindingMode::ClassStringInner => match default_value {
+                    Some(d) => d,
+                    None => continue,
+                },
+                TemplateBindingMode::Direct => match default_value {
+                    Some(d) if d.ends_with("::class") => d,
+                    _ => continue,
+                },
+                _ => continue,
+            },
+        };
+
         match binding_mode {
             TemplateBindingMode::Direct => {
                 if let Some(resolved_type) = Backend::resolve_arg_text_to_type(arg_text, rctx) {