Empty subject string in type resolution

Author: AJenbo

docs/CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Null-safe method chain resolution.** Null-safe method calls (`$obj?->method()`) now resolve the return type correctly for variable type inference, including cross-file chains. Previously `?->` calls were ignored by the RHS resolution pipeline, losing the type for any variable assigned from a null-safe chain.
 - **Nullable and generic types in class lookup.** Variables typed as `?ClassName` or `Collection<Item>` now resolve correctly across all code paths. Previously the `?` prefix and generic parameters were not stripped before class lookup, causing the type engine to treat them as unknown types. This fixes completion, hover, go-to-definition, and false-positive diagnostics for any variable whose type uses the nullable shorthand or carries generic arguments.
 - **`@see` references with qualified class names.** Docblock `@see Fully\Qualified\ClassName` references no longer have the file's namespace prepended, which previously produced doubled names like `App\Models\App\Models\User`. Qualified names in `@see` tags are now treated as fully-qualified.
+- **Ternary and null-coalesce member access.** Accessing a member on a ternary or null-coalesce expression (e.g. `($a ?: $b)->property`, `($x ?? $y)->method()`) now resolves correctly for hover, go-to-definition, and diagnostics. Previously the subject extraction produced an empty string, causing a confusing "Cannot resolve type of ''" hint and no hover information.
 - **False-positive diagnostics for same-named variables in different methods.** When two methods in the same class both used a variable like `$order`, the diagnostic cache resolved it once and reused that type for every other method in the class. The second method saw the wrong type and flagged valid member accesses as unknown. Both the per-file subject cache and the cross-collector resolution cache are now scoped to the enclosing function/method/closure body, so each method resolves variables independently.
 - **False-positive diagnostics for `$this` inside traits.** Accessing host-class members via `$this->`, `self::`, `static::`, or `parent::` inside a trait method no longer produces "not found" warnings. Traits are incomplete by nature and expect the host class to provide these members.
 - **Type narrowing inside `return` statements.** `instanceof` checks in `&&` chains and ternary conditions now narrow the variable type when the expression is the operand of a `return` statement. Previously, `return $e instanceof QueryException && $e->errorInfo;` would flag `errorInfo` as unknown because narrowing only applied inside standalone expression statements and `if` conditions.

docs/todo.md

@@ -103,7 +103,6 @@ unlikely to move the needle for most users.
 |     | **[Bugs](todo/bugs.md)**                                                                                                                                     |             |             |
 | B3  | [Trait static/self suppression not applied inside closures](todo/bugs.md#b3-trait-staticself-suppression-not-applied-inside-closures)                         | Medium      | Low         |
 | B4  | [Variable reassignment loses type when parameter name is reused](todo/bugs.md#b4-variable-reassignment-loses-type-when-parameter-name-is-reused)             | Medium      | Medium      |
-| B6  | [Empty subject string in diagnostic messages](todo/bugs.md#b6-empty-subject-string-in-diagnostic-messages)                                                   | Low         | Low         |
 | B7  | [Overloaded built-in function signatures in stubs](todo/bugs.md#b7-overloaded-built-in-function-signatures-in-stubs)                                         | Low         | Low         |
 | B8  | [`getCode`/`getMessage` not found through deep inheritance chains](todo/bugs.md#b8-getcodemessage-not-found-through-deep-inheritance-chains)                 | Low         | Low         |
 |     | **[Completion](todo/completion.md)**                                                                                                                         |             |             |

docs/todo/bugs.md

@@ -79,29 +79,6 @@ within the same scope at the cursor offset.
 
 ---
 
-#### B6. Empty subject string in type resolution
-
-| | |
-|---|---|
-| **Impact** | Low |
-| **Effort** | Low |
-
-The subject extraction produces an empty string for complex expressions
-like `($a ?: $b)?->property`, meaning the type engine has no subject
-to resolve. This manifests as "Cannot resolve type of ''" in
-diagnostics, but the underlying issue is that `expr_to_subject_text`
-does not handle ternary-inside-nullable and similar compound patterns.
-
-**Observed:** 5 cases in `shared` with empty subject strings.
-
-**Fix:** Extend `expr_to_subject_text` to handle parenthesised ternary
-expressions, short ternary (`?:`), and null-coalesce (`??`) as subject
-bases. When the expression is too complex to represent as a subject
-string, the type engine should skip the access rather than attempt
-resolution with an empty key.
-
----
-
 #### B7. Overloaded built-in function signatures not representable in stubs
 
 | | |

src/diagnostics/unknown_members.rs

@@ -427,7 +427,7 @@ impl Backend {
                         // usually because the symbol map's subject_text
                         // doesn't preserve full argument text, not because
                         // the user is missing a type annotation.
-                        if !subject_text.contains('(') {
+                        if !subject_text.is_empty() && !subject_text.contains('(') {
                             let range = match offset_range_to_lsp_range(
                                 content,
                                 span.start as usize,

src/symbol_map/extraction.rs

@@ -2377,6 +2377,30 @@ fn expr_to_subject_text(expr: &Expression<'_>) -> String {
             format!("[{}]", parts.join(", "))
         }
 
+        // Ternary `$a ? $b : $c` and short ternary `$a ?: $b`.
+        // For short ternary (`then` is None), the condition is the
+        // preferred branch; for full ternary, use the `then` branch.
+        // Either way we pick one branch so the type engine has
+        // something to resolve rather than an empty string.
+        Expression::Conditional(cond) => {
+            let preferred = cond.then.unwrap_or(cond.condition);
+            let text = expr_to_subject_text(preferred);
+            if !text.is_empty() {
+                return text;
+            }
+            // Fall back to the else branch.
+            expr_to_subject_text(cond.r#else)
+        }
+
+        // Null coalesce `$a ?? $b` — LHS is the preferred non-null value.
+        Expression::Binary(binary) if binary.operator.is_null_coalesce() => {
+            let text = expr_to_subject_text(binary.lhs);
+            if !text.is_empty() {
+                return text;
+            }
+            expr_to_subject_text(binary.rhs)
+        }
+
         Expression::ArrayAccess(access) => {
             let base = expr_to_subject_text(access.array);
             if base.is_empty() {

tests/completion_variables.rs

@@ -16889,6 +16889,138 @@ async fn test_completion_nullsafe_method_chain_cross_file() {
     }
 }
 
+// ─── Ternary / null-coalesce RHS resolution (B6) ────────────────────────────
+
+/// Short ternary as RHS: `$p = $cond ?: new Printer()` should resolve `$p`.
+#[tokio::test]
+async fn test_completion_short_ternary_rhs_instantiation() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///short_ternary.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class Printer {\n",
+        "    public function print(): void {}\n",
+        "}\n",
+        "class Demo {\n",
+        "    public function run(): void {\n",
+        "        $p = null ?: new Printer();\n",
+        "        $p->\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    let completion_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position {
+                line: 7,
+                character: 12,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let result = backend.completion(completion_params).await.unwrap();
+    assert!(
+        result.is_some(),
+        "Completion should return results for short ternary RHS"
+    );
+
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let names: Vec<&str> = items
+                .iter()
+                .filter(|i| i.kind == Some(CompletionItemKind::METHOD))
+                .map(|i| i.filter_text.as_deref().unwrap())
+                .collect();
+            assert!(
+                names.contains(&"print"),
+                "Should include 'print' from Printer via ternary, got: {:?}",
+                names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}
+
+/// Full ternary as RHS with instantiation on both branches.
+#[tokio::test]
+async fn test_completion_full_ternary_rhs_instantiation() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///full_ternary.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class Renderer {\n",
+        "    public function render(): string { return ''; }\n",
+        "}\n",
+        "class Page {\n",
+        "    public function show(bool $flag): void {\n",
+        "        $r = $flag ? new Renderer() : new Renderer();\n",
+        "        $r->\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    let completion_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position {
+                line: 7,
+                character: 12,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let result = backend.completion(completion_params).await.unwrap();
+    assert!(
+        result.is_some(),
+        "Completion should return results for full ternary RHS"
+    );
+
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let names: Vec<&str> = items
+                .iter()
+                .filter(|i| i.kind == Some(CompletionItemKind::METHOD))
+                .map(|i| i.filter_text.as_deref().unwrap())
+                .collect();
+            assert!(
+                names.contains(&"render"),
+                "Should include 'render' from Renderer via ternary, got: {:?}",
+                names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}
+
 // ─── Nullable type resolution (B1) ──────────────────────────────────────────
 
 /// A parameter typed `?ClassName` should resolve to `ClassName` for completion.

tests/hover.rs

@@ -7986,3 +7986,92 @@ class Demo {
         text
     );
 }
+
+// ─── Ternary / null-coalesce subject extraction (B6) ────────────────────────
+
+#[test]
+fn hover_short_ternary_member_access() {
+    let backend = create_test_backend();
+    let uri = "file:///b6_short_ternary.php";
+    let content = r#"<?php
+class Gadget {
+    public string $label = '';
+}
+class B6Demo {
+    public function run(?Gadget $a, Gadget $b): void {
+        ($a ?: $b)->label;
+    }
+}
+"#;
+
+    // Hover on `label` in `($a ?: $b)->label` (line 6, character 21)
+    let hover = hover_at(&backend, uri, content, 6, 21);
+    assert!(
+        hover.is_some(),
+        "hover should resolve the member through short ternary subject"
+    );
+    let text = hover_text(hover.as_ref().unwrap());
+    assert!(
+        text.contains("label"),
+        "hover should mention 'label', got: {}",
+        text
+    );
+}
+
+#[test]
+fn hover_null_coalesce_member_access() {
+    let backend = create_test_backend();
+    let uri = "file:///b6_null_coalesce.php";
+    let content = r#"<?php
+class Sensor {
+    public int $value = 0;
+}
+class B6Demo2 {
+    public function run(?Sensor $a, Sensor $b): void {
+        ($a ?? $b)->value;
+    }
+}
+"#;
+
+    // Hover on `value` in `($a ?? $b)->value` (line 6, character 21)
+    let hover = hover_at(&backend, uri, content, 6, 21);
+    assert!(
+        hover.is_some(),
+        "hover should resolve the member through null-coalesce subject"
+    );
+    let text = hover_text(hover.as_ref().unwrap());
+    assert!(
+        text.contains("value"),
+        "hover should mention 'value', got: {}",
+        text
+    );
+}
+
+#[test]
+fn hover_full_ternary_member_access() {
+    let backend = create_test_backend();
+    let uri = "file:///b6_full_ternary.php";
+    let content = r#"<?php
+class Engine {
+    public function start(): void {}
+}
+class B6Demo3 {
+    public function run(bool $flag, Engine $a, Engine $b): void {
+        ($flag ? $a : $b)->start();
+    }
+}
+"#;
+
+    // Hover on `start` in `($flag ? $a : $b)->start()` (line 6, character 28)
+    let hover = hover_at(&backend, uri, content, 6, 28);
+    assert!(
+        hover.is_some(),
+        "hover should resolve the member through full ternary subject"
+    );
+    let text = hover_text(hover.as_ref().unwrap());
+    assert!(
+        text.contains("start"),
+        "hover should mention 'start', got: {}",
+        text
+    );
+}