Fix instanceof narrowing with unresolvable target class

Author: AJenbo

docs/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **`instanceof` narrowing with unresolvable target class.** When the `instanceof` target class cannot be loaded (e.g. it lives inside a phar archive), the variable's type is now treated as unknown instead of keeping the un-narrowed base type. This eliminates false-positive "unknown member" diagnostics for members that only exist on the narrowed subclass. Applies to all narrowing contexts: if-bodies, ternary expressions, `assert()` statements, and inline `&&` chains.
 - **`DB::select()` return type.** `DB::select()`, `DB::selectFromWriteConnection()`, and `DB::selectResultSets()` now return `array<int, stdClass>` instead of bare `array`, and `DB::selectOne()` returns `?stdClass` instead of `mixed`. Property access on query results (e.g. `$result[0]->column_name`) no longer produces false-positive diagnostics. The same fix applies to the underlying `Illuminate\Database\Connection` class.
 - **Redis `Connection` method resolution.** `Illuminate\Redis\Connections\Connection` now has `@mixin \Redis` applied automatically, so Redis commands like `del()`, `get()`, `set()`, etc. resolve through the phpredis stubs instead of producing false-positive diagnostics.
 
@@ -57,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **Diagnostics.** Unified the diagnostic type-resolution pipeline with the completion and hover pipeline. Variable resolution now produces the same result in all three contexts, eliminating a class of false positives where diagnostics disagreed with completion about a variable's type.
 - **`@phpstan-ignore` is never the preferred quickfix.** The "Ignore PHPStan error" code action now explicitly sets `is_preferred: false`. Previously it used `None`, which some editors treated as absent, causing the suppress-with-comment action to be applied on the keyboard shortcut (e.g. Ctrl+. then Enter) when no other quickfix set `is_preferred`.
 
 - **Generate PHPDoc infers `@return` from the function body.** Typing `/**` above a function that returns `array` now produces `@return list<string>` (or whatever the body actually returns) instead of the previous `@return array<mixed>`. The same return-statement scanning used by the `missingType.return` and `missingType.iterableValue` code actions is now shared with docblock generation.

docs/todo.md

@@ -23,7 +23,6 @@ within the same impact tier.
 
 | #   | Item                                                                                                                                                      | Impact | Effort     |
 | --- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ---------- |
-| B10 | [`instanceof` ternary narrowing fails when target class is in a phar](todo/bugs.md#b10-instanceof-ternary-narrowing-fails-when-target-class-is-in-a-phar) | Low    | Low-Medium |
 | B12 | [`Collection::reduce()` generic return type not inferred](todo/bugs.md#b12-collectionreduce-generic-return-type-not-inferred)                             | Low    | Medium     |
 | B13 | [Array shape tracking from keyed literal assignments in loops](todo/bugs.md#b13-array-shape-tracking-from-keyed-literal-assignments-in-loops)             | Low    | High       |
 | H10 | [`return.unusedType` — remove unused type from return union](todo/phpstan-actions.md#h10-returnunusedtype--remove-unused-type-from-return-union)          | Medium | Medium     |

docs/todo/bugs.md

@@ -1,40 +1,5 @@
 # PHPantom — Bug Fixes
 
-## B10. `instanceof` ternary narrowing fails when target class is in a phar
-**Impact: Low · Effort: Low-Medium**
-
-Pattern:
-```php
-$types = $argType instanceof UnionType ? $argType->getTypes() : [$argType];
-```
-
-The type engine is unified: completion and diagnostics both use
-`resolve_variable_types` → `walk_statements_for_assignments` →
-`try_apply_ternary_instanceof_narrowing`. A local-class test
-(assignment RHS context, interface parameter, `instanceof` subclass
-in ternary condition) passes with zero diagnostics.
-
-The failure in the shared project is specific to PHPStan phar classes.
-`PHPStan\Type\UnionType` lives inside `phpstan.phar` and may not be
-loadable at resolution time, so `apply_instanceof_inclusion` silently
-fails (cannot resolve the class name to a `ClassInfo`), and the
-variable keeps its un-narrowed type (`Type`).
-
-**Observed in:** `DecimalDivThrowTypeExtension:54` — `$argType` is
-typed as `PHPStan\Type\Type`, `getTypes()` exists on `UnionType` but
-not on the `Type` interface. The `instanceof UnionType` check in the
-ternary condition should narrow the type in the then-branch.
-
-**Root cause:** The `instanceof` target class (`UnionType`) cannot be
-loaded from the phar, so `apply_instanceof_inclusion` has no
-`ClassInfo` to narrow to. The narrowing architecture itself is correct
-and unified across completion and diagnostics. The fix is either
-phar class indexing or suppressing diagnostics when the `instanceof`
-target class is unresolvable (since the developer clearly expects
-narrowing to occur).
-
----
-
 ## B12. `Collection::reduce()` generic return type not inferred
 **Impact: Low · Effort: Medium**
 
@@ -101,5 +66,4 @@ unresolvable because the shape is lost.
 
 **Depends on:** T19 (structured type representation) or at minimum
 a basic array shape inference that preserves `array{key: Type}` from
-literal array constructors and propagates it through foreach.
-
+literal array constructors and propagates it through foreach.

src/completion/call_resolution.rs

@@ -144,7 +144,11 @@ impl Backend {
                 .into_iter()
                 .collect()
         } else {
-            super::resolver::resolve_target_classes(&subject_text, crate::AccessKind::Arrow, rctx)
+            ResolvedType::into_arced_classes(super::resolver::resolve_target_classes(
+                &subject_text,
+                crate::AccessKind::Arrow,
+                rctx,
+            ))
         };
 
         for owner in &owner_classes {
@@ -399,8 +403,9 @@ impl Backend {
                 let method_name = method.as_str();
 
                 // Resolve the base expression to class(es).
-                let lhs_classes: Vec<Arc<ClassInfo>> =
-                    super::resolver::resolve_target_classes_expr(base, AccessKind::Arrow, ctx);
+                let lhs_classes: Vec<Arc<ClassInfo>> = ResolvedType::into_arced_classes(
+                    super::resolver::resolve_target_classes_expr(base, AccessKind::Arrow, ctx),
+                );
 
                 let mut results = Vec::new();
                 for owner in &lhs_classes {
@@ -432,9 +437,13 @@ impl Backend {
 
                 let owner_class = if class.starts_with('$') {
                     // Variable holding a class-string (e.g. `$cls::make()`).
-                    super::resolver::resolve_target_classes(class, AccessKind::DoubleColon, ctx)
-                        .into_iter()
-                        .next()
+                    ResolvedType::into_arced_classes(super::resolver::resolve_target_classes(
+                        class,
+                        AccessKind::DoubleColon,
+                        ctx,
+                    ))
+                    .into_iter()
+                    .next()
                 } else {
                     super::resolver::resolve_static_owner_class(class, ctx)
                 };
@@ -659,8 +668,9 @@ impl Backend {
                 // 4. Resolve the variable's type and check for __invoke().
                 //    When $f holds an object with an __invoke() method,
                 //    $f() should return __invoke()'s return type.
-                let var_classes =
-                    super::resolver::resolve_target_classes(var_name, AccessKind::Arrow, ctx);
+                let var_classes = ResolvedType::into_arced_classes(
+                    super::resolver::resolve_target_classes(var_name, AccessKind::Arrow, ctx),
+                );
                 for owner in &var_classes {
                     if let Some(invoke) = owner.methods.iter().find(|m| m.name == "__invoke")
                         && let Some(ref ret) = invoke.return_type
@@ -699,8 +709,9 @@ impl Backend {
             //    from a function name) ───────────────────────────────
             _ => {
                 // Resolve the callee expression to class(es).
-                let callee_classes =
-                    super::resolver::resolve_target_classes_expr(callee, AccessKind::Arrow, ctx);
+                let callee_classes = ResolvedType::into_arced_classes(
+                    super::resolver::resolve_target_classes_expr(callee, AccessKind::Arrow, ctx),
+                );
 
                 // When the callee resolves to an object with __invoke(),
                 // the call returns __invoke()'s return type, not the
@@ -1308,7 +1319,13 @@ impl Backend {
                 ctx,
             );
             if let Some(first) = classes.first() {
-                return Some(first.name.clone());
+                return Some(
+                    first
+                        .class_info
+                        .as_ref()
+                        .map(|ci| ci.name.clone())
+                        .unwrap_or_else(|| first.type_string.to_string()),
+                );
             }
         }
 
@@ -1402,8 +1419,9 @@ impl Backend {
                     .unwrap_or(&call_body[..pos]);
                 let method_name = &call_body[pos + 2..];
 
-                let lhs_classes =
-                    super::resolver::resolve_target_classes(lhs, AccessKind::Arrow, ctx);
+                let lhs_classes = ResolvedType::into_arced_classes(
+                    super::resolver::resolve_target_classes(lhs, AccessKind::Arrow, ctx),
+                );
                 for cls in &lhs_classes {
                     if let Some(rt) = crate::inheritance::resolve_method_return_type(
                         cls,
@@ -1447,8 +1465,9 @@ impl Backend {
                 .unwrap_or(&arg_text[..pos]);
             let prop_name = &arg_text[pos + 2..];
             if !prop_name.is_empty() && prop_name.chars().all(|c| c.is_alphanumeric() || c == '_') {
-                let lhs_classes =
-                    super::resolver::resolve_target_classes(lhs, AccessKind::Arrow, ctx);
+                let lhs_classes = ResolvedType::into_arced_classes(
+                    super::resolver::resolve_target_classes(lhs, AccessKind::Arrow, ctx),
+                );
                 for cls in &lhs_classes {
                     if let Some(rt) =
                         crate::inheritance::resolve_property_type_hint(cls, prop_name, class_loader)

src/completion/handler.rs

@@ -41,7 +41,7 @@ use crate::completion::class_completion::{
 use crate::completion::named_args::{NamedArgContext, parse_existing_args};
 use crate::docblock::types::PHPDOC_TYPE_KEYWORDS;
 use crate::symbol_map::SymbolKind;
-use crate::types::ClassInfo;
+use crate::types::{ClassInfo, ResolvedType};
 use crate::types::{CompletionTarget, FileContext};
 use crate::util::{find_class_at_offset, position_to_byte_offset, position_to_offset};
 
@@ -911,7 +911,7 @@ impl Backend {
                         }
                     }
 
-                    resolved
+                    ResolvedType::into_arced_classes(resolved)
                 };
                 if candidates.is_empty() {
                     return vec![];