Fix conditional return type resolution for chained calls with complex

arguments

Author: AJenbo

docs/CHANGELOG.md

@@ -107,6 +107,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **False-positive diagnostics on startup.** Files opened while the project was still indexing could produce spurious "class not found" errors. Diagnostics are now deferred until initialization completes.
 - **Analyzer and LSP no longer hang on files with deeply nested loops.**
 - **Infinite loop on array key reassignment patterns.** Files containing `$arr['key'] = f($arr['key'])` no longer hang the analyzer.
+- **Chained calls with complex arguments resolve the correct return type.** Calling `redirect($string . $var)->with(...)` now resolves to `RedirectResponse` as expected. Complex argument expressions (concatenation, method calls, etc.) were previously serialized as empty, causing conditional return types to take the wrong branch.
 - **Stack overflow on large codebases and large files.** The `analyze` command no longer crashes with stack overflows on large files.
 - **Non-deterministic diagnostic counts eliminated.** Projects with heavy use of generics no longer see false positives that vary between runs.
 - **Pull-diagnostic reliability.** Editors that support pull diagnostics no longer show duplicate or stale diagnostics.

src/symbol_map/extraction.rs

@@ -3069,9 +3069,12 @@ fn format_all_call_args(args: &TokenSeparatedSequence<'_, Argument<'_>>) -> Stri
         let text = format_arg_expr(arg_expr);
         parts.push(text);
     }
-    // Trim trailing `...` placeholders so that simple single-arg calls
-    // (the common case) don't produce `method(Foo::class, ...)`.
-    while parts.last().is_some_and(|p| p == "...") {
+    // Trim trailing `...` placeholders beyond the first argument so
+    // that multi-arg calls like `method(Foo::class, ...)` don't grow
+    // a long tail of placeholders, but a single unknown argument still
+    // produces `func(...)` rather than `func()` (which would look like
+    // a no-arg call and break conditional return-type resolution).
+    while parts.len() > 1 && parts.last().is_some_and(|p| p == "...") {
         parts.pop();
     }
     parts.join(", ")

tests/integration/diagnostics_unknown_members.rs

@@ -4877,3 +4877,87 @@ class Test {
         diags.iter().map(|d| &d.message).collect::<Vec<_>>()
     );
 }
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Conditional return types — redirect() helper
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// `redirect($to)` has `@return ($to is null ? Redirector : RedirectResponse)`.
+/// When called with a non-null argument (including string concatenation),
+/// the return type must resolve to `RedirectResponse`, which carries `with()`
+/// and `withErrors()`.  No `unknown_member` diagnostic should fire.
+#[test]
+fn redirect_with_concat_arg_resolves_to_redirect_response() {
+    let (backend, _dir) = create_psr4_workspace(
+        r#"{"autoload":{"psr-4":{"App\\":"/src/"}}}"#,
+        &[
+            (
+                "helpers.php",
+                r#"<?php
+namespace {
+    use Illuminate\Routing\Redirector;
+    use Illuminate\Http\RedirectResponse;
+
+    /**
+     * @return ($to is null ? \Illuminate\Routing\Redirector : \Illuminate\Http\RedirectResponse)
+     */
+    function redirect(?string $to = null): Redirector|RedirectResponse
+    {
+        return new RedirectResponse();
+    }
+}
+"#,
+            ),
+            (
+                "src/Routing/Redirector.php",
+                r#"<?php
+namespace Illuminate\Routing;
+class Redirector {}
+"#,
+            ),
+            (
+                "src/Http/RedirectResponse.php",
+                r#"<?php
+namespace Illuminate\Http;
+class RedirectResponse {
+    public function with(string $key, mixed $value = null): static {}
+    public function withErrors(mixed $provider, string $key = 'default'): static {}
+}
+"#,
+            ),
+            (
+                "src/Controller.php",
+                r#"<?php
+namespace App;
+class Customer { public int $id = 0; }
+class MyController {
+    public function action(Customer $customer): void {
+        // String concatenation arg — must resolve to RedirectResponse.
+        redirect('/users/' . $customer->id . '#tab')->with('msg', 'ok');
+        redirect('/users/' . $customer->id)->withErrors(['e']);
+        // Assigned form works too (baseline sanity check).
+        $r = redirect('/users/' . $customer->id);
+        $r->with('msg', 'ok');
+    }
+}
+"#,
+            ),
+        ],
+    );
+
+    let uri = "file:///src/Controller.php";
+    let content = std::fs::read_to_string(
+        std::path::Path::new(_dir.path()).join("src/Controller.php"),
+    )
+    .unwrap();
+    let diags = unknown_member_diagnostics_with_scope_cache(&backend, uri, &content);
+    let with_diags: Vec<_> = diags
+        .iter()
+        .filter(|d| d.message.contains("with") || d.message.contains("withErrors"))
+        .collect();
+    assert!(
+        with_diags.is_empty(),
+        "redirect()->with()/withErrors() should resolve to RedirectResponse. Got: {:?}",
+        with_diags
+    );
+}