Eliminate false positives for properties narrowed via instanceof checks

Author: AJenbo

docs/CHANGELOG.md

@@ -29,6 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Magic `__get` property access.** Accessing undefined properties on objects with a `__get` method now resolves to the method's declared return type, even when `__get` has no template parameters (e.g. `SimpleXMLElement::$child` resolves to `SimpleXMLElement`).
 - **Magic `__call` method return type.** Calling undefined methods on objects with a `__call` method now resolves to `__call`'s declared return type for hover and type inference.
 - **SoapClient arbitrary methods.** Calling any method on `SoapClient` (or subclasses) no longer produces false-positive "unknown member" diagnostics. SoapClient is a SOAP proxy where any method name is valid at runtime.
+- **Property narrowing in type error diagnostics.** Properties narrowed via `instanceof` checks (e.g. `if ($this->service instanceof MockInterface)`) now use the narrowed type when checking argument compatibility, eliminating false positives in test code that uses Mockery or similar patterns.
 - **`self::class` and `static::class` in template arguments.** Passing `self::class` or `static::class` to a method with `@template T` + `@param class-string<T>` now correctly resolves T to the enclosing class instead of failing to resolve or resolving to the called class.
 - **Bare array return values no longer flagged against typed array parameters.** When a method returns `array` (without generic parameters), passing the result to a parameter expecting `array<T>` no longer triggers a false type mismatch error.
 - **Foreach over `::class` literal arrays resolves static access.** Variables assigned from `foreach ([A::class, B::class] as $className)` are now recognized as class-strings, so `$className::CONST` and `$className::method()` no longer produce unresolved-member-access diagnostics.

src/completion/resolver.rs

@@ -1359,7 +1359,7 @@ pub(in crate::completion) fn resolve_static_owner_class(
 /// [`super::types::narrowing`] already support property paths via
 /// [`super::types::narrowing::expr_to_subject_key`], so no changes
 /// to those functions are required.
-fn apply_property_narrowing(
+pub(crate) fn apply_property_narrowing(
     property_path: &str,
     current_class: &ClassInfo,
     rctx: &ResolutionCtx<'_>,

src/completion/variable/class_string_resolution.rs

@@ -174,8 +174,7 @@ fn walk_class_string_assignments<'b>(
                 {
                     // Extract class names from the iterated expression
                     // (e.g. `[Page::class, CustomPage::class]`).
-                    let class_names =
-                        extract_class_string_names_from_array(foreach.expression);
+                    let class_names = extract_class_string_names_from_array(foreach.expression);
                     if !class_names.is_empty() {
                         results.clear();
                         for cn in class_names {
@@ -187,9 +186,7 @@ fn walk_class_string_assignments<'b>(
                                 cn
                             };
                             let lookup = short_name(&resolved_name);
-                            if let Some(cls) =
-                                ctx.all_classes.iter().find(|c| c.name == lookup)
-                            {
+                            if let Some(cls) = ctx.all_classes.iter().find(|c| c.name == lookup) {
                                 ClassInfo::push_unique(results, ClassInfo::clone(cls));
                             } else if let Some(cls) = (ctx.class_loader)(&resolved_name) {
                                 ClassInfo::push_unique(results, Arc::unwrap_or_clone(cls));

src/completion/variable/rhs_resolution.rs

@@ -314,7 +314,40 @@ fn resolve_rhs_expression_inner<'b>(
                     return from_scope;
                 }
             }
-            resolve_rhs_property_access(access, ctx)
+            let result = resolve_rhs_property_access(access, ctx);
+            // When no scope_var_resolver is available (e.g. type error
+            // diagnostic), apply property narrowing from enclosing
+            // if-conditions (instanceof checks).  This ensures that
+            // `$this->prop` inside `if ($this->prop instanceof X)`
+            // resolves to X instead of the declared property type.
+            if ctx.scope_var_resolver.is_none()
+                && !result.is_empty()
+                && let Some(key) = crate::completion::types::narrowing::expr_to_subject_key(expr)
+                && key.contains("->")
+            {
+                let rctx = ctx.as_resolution_ctx();
+                let mut classes: Vec<Arc<ClassInfo>> =
+                    result.iter().filter_map(|r| r.class_info.clone()).collect();
+                if !classes.is_empty() {
+                    crate::completion::resolver::apply_property_narrowing(
+                        &key,
+                        ctx.current_class,
+                        &rctx,
+                        &mut classes,
+                    );
+                    // If narrowing changed the classes, return the narrowed result.
+                    let original_names: Vec<&str> = result
+                        .iter()
+                        .filter_map(|r| r.class_info.as_ref().map(|c| c.name.as_str()))
+                        .collect();
+                    let narrowed_names: Vec<&str> =
+                        classes.iter().map(|c| c.name.as_str()).collect();
+                    if original_names != narrowed_names {
+                        return ResolvedType::from_classes(classes);
+                    }
+                }
+            }
+            result
         }
         Expression::Parenthesized(p) => resolve_rhs_expression(p.expression, ctx),
         Expression::Match(match_expr) => {

tests/integration/diag_timing.rs

@@ -15,7 +15,9 @@
 //! invalidation, classes from unedited files stay cached and the second
 //! pass is significantly faster.
 
-use crate::common::{create_psr4_workspace, create_test_backend, create_test_backend_with_full_stubs};
+use crate::common::{
+    create_psr4_workspace, create_test_backend, create_test_backend_with_full_stubs,
+};
 use std::time::Instant;
 use tower_lsp::lsp_types::NumberOrString;
 

tests/integration/diagnostics_type_errors.rs

@@ -3831,3 +3831,34 @@ class Controller {
         "Should not flag bare array from method return as incompatible with typed array param, got: {msgs:?}"
     );
 }
+
+#[test]
+fn no_false_positive_for_property_narrowed_via_instanceof() {
+    let php = r#"<?php
+interface MockInterface {
+    public function shouldReceive(string $name): self;
+}
+
+class EpaymentService {
+    public function annul(): bool { return true; }
+}
+
+class TestCase {
+    private EpaymentService $service;
+
+    protected function mockMethod(MockInterface $mock, string $method): void {}
+
+    public function test(): void {
+        if ($this->service instanceof MockInterface) {
+            $this->mockMethod($this->service, 'annul');
+        }
+    }
+}
+"#;
+    let diags = collect(php);
+    let msgs = type_error_messages(&diags);
+    assert!(
+        msgs.is_empty(),
+        "Property narrowed via instanceof should be accepted as MockInterface, got: {msgs:?}"
+    );
+}