Suppress diagnostics for stdClass and object property access

Author: AJenbo

docs/CHANGELOG.md

@@ -75,6 +75,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Hover on the `$` sign of a variable at its assignment site showed no type.** Hovering on the `$` of `$order = new Order()` displayed a bare `$order` with no type information, while hovering one character to the right on `o` worked correctly. The variable's byte offset coincided with the assignment statement's start offset, causing the resolver to skip the assignment entirely. The cursor offset is now nudged past the statement boundary so the assignment is included.
 - **Method chains through `__call` no longer lose the return type.** When a class defines `__call` and an unrecognized method is called (e.g. dynamic `whereColumn()` on an Eloquent Builder), the return type of `__call` is now used as a fallback. If `__call` returns `$this`, `static`, or `self`, the chain type is preserved so subsequent calls continue resolving. Previously the type was lost at the first dynamic call, breaking every link after it. Eloquent Builder's `__call` is patched from `mixed` to `static` during resolution, matching its runtime behavior (scope dispatch, macro dispatch, and Query\Builder forwarding all return the Builder instance).
 - **Callable parameter inference now preserves generic arguments from the receiver.** When a closure parameter is typed as a bare supertype (e.g. `fn(Builder $q)`) but the enclosing method's callable signature provides a more specific type via `$this` or `static` (e.g. `callable($this)`), the inferred type now carries the receiver's generic arguments. For example, calling `->when($flag, fn(Builder $q) => $q->active())` on a `Builder<Product>` chain now infers `$q` as `Builder<Product>`, so model-specific scope methods resolve correctly instead of being flagged as unknown.
+- **`stdClass` and `object` types no longer produce false-positive diagnostics.** Variables typed as `object` (via parameter type, `@var`, or type-guard narrowing) and `stdClass` now permit arbitrary property access without `unresolved_member_access` diagnostics. Type-guard functions like `is_object()` now narrow `mixed` to `object` instead of filtering it to empty. Compound `&&` conditions propagate type-guard narrowing to both the condition's right-hand operands and the if-body, so `if (is_object($data) && $data->name)` resolves correctly throughout.
 - **Null narrowing from `!== null` checks in conditions.** When a null-initialized variable was guarded by `$var !== null` in an `if` or `while` condition, the variable still showed `null` in its type inside the condition's `&&` operands and inside the then-body. The `!== null` check (and `!is_null()`, bare truthy guards) now narrows away `null` both for subsequent `&&` operands and inside the corresponding body block. Chained conditions like `$a !== null && $b !== null && $a->method()` narrow all checked variables. Conditions wrapped inside ternary expressions and return statements are also handled.
 - **Variables assigned inside `if`/`while` conditions now resolve in the body.** `if ($admin = AdminUser::first())` and `while ($row = nextRow())` now register the assignment so the variable has a type inside the loop or branch body. Assignments wrapped in comparisons like `if (($conn = getConn()) !== null)` are also recognized.
 - **Fluent chains only flag the first broken link.** In a chain like `$m->callHome()->callMom()->callDad()` where `callHome` does not exist, only `callHome` is flagged. Previously every subsequent link received its own "cannot verify" warning, burying the root cause in noise. Separate statements on the same variable (`$m->callHome(); $m->callMom();`) still flag independently. Scalar member access chains (`$user->getAge()->value->deep`) flag only the first scalar break. Null-safe, static, and mixed-operator chains are all handled.

docs/todo.md

@@ -23,7 +23,6 @@ within the same impact tier.
 
 | #   | Item                                                                                                                                             | Impact      | Effort      |
 | --- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ----------- |
-| T24 | [`stdClass` dynamic property access](todo/type-inference.md#t24-stdclass-dynamic-property-access) (suppress diagnostics on `stdClass`/`object`)  | Low-Medium  | Low         |
 | T22 | [Array value type tracking from loop assignments](todo/type-inference.md#t22-array-value-type-tracking-from-loop-assignments)                    | Medium      | Medium      |
 | T23 | [`class-string<T>` static method dispatch](todo/type-inference.md#t23-class-stringt-static-method-dispatch)                                     | Medium      | Medium      |
 | T21 | [Bidirectional template inference](todo/type-inference.md#t21-bidirectional-template-inference-upperlower-bounds) (closure return type → generic) | Medium      | Medium-High |

docs/todo/type-inference.md

@@ -589,24 +589,27 @@ via `is_object()`) should not produce `unresolved_member_access`
 diagnostics, because `stdClass` permits arbitrary properties by
 design.
 
-This affects two common patterns:
-
-1. `json_decode($json, false)` returns `mixed`. After an
-   `is_object($data)` guard, `$data` should narrow to `object`, and
-   property access like `$data->error_link` should be permitted
-   without a diagnostic. (`Order:646,647`.)
-2. `DB::select()` returns `array`. After `$result[0] instanceof
-   stdClass`, the element should narrow to `stdClass` and property
-   access should be permitted. (`PurchaseFileService:1081,1083`.)
-
-Both patterns also depend on narrowing improvements tracked in T20
-(`is_object()` narrowing, `instanceof` on array element access).
-This item covers the additional step: once the type is narrowed to
-`stdClass` or `object`, suppress member-not-found diagnostics.
-
-**Implementation:** in the diagnostic emission path for
-`unknown_member` and `unresolved_member_access`, skip the diagnostic
-when the resolved type is `stdClass` or bare `object`. Optionally,
-resolve any property access on `stdClass` as `mixed`.
+**Partially resolved.** Three changes landed:
+
+1. `filter_type_by_guard` now narrows `mixed` → the canonical type
+   for each guard kind (e.g. `is_object()` → `object`) instead of
+   filtering `mixed` to empty.
+2. `resolve_subject_outcome_variable` returns a synthetic
+   `Resolved(stdClass)` when the resolved type is `object` or
+   `stdClass`, so the existing `check_member_on_resolved_classes`
+   suppression kicks in.
+3. `try_apply_type_guard_narrowing` decomposes compound `&&`
+   conditions so `if (is_object($x) && $x->prop)` narrows in both
+   the condition RHS and the if-body. `apply_and_lhs_narrowing` also
+   handles `is_object()` in `&&` inline narrowing.
+
+This fixed `Order:646,647` (`json_decode` → `mixed` → `is_object`
+guard → property access).
+
+**Remaining:** `PurchaseFileService:1081,1083` — `$result[0]
+instanceof stdClass` where `$result` is bare `array` from
+`DB::select()`. This requires `instanceof` narrowing on array
+element access expressions, which is a T20 concern (the narrowing
+system only matches bare variable names, not `$arr[0]`).
 
 ---

example.php

@@ -253,6 +253,20 @@ public function demo(null|array|Pen $input): void
         if (is_object($mixed)) {
             $mixed->weigh();                      // both Rock and Banana have weigh()
         }
+
+        // is_object() narrows mixed → object, suppressing diagnostics
+        // on dynamic property access (stdClass / object permit any property).
+        $decoded = json_decode('{}');             // mixed
+        if (is_object($decoded)) {
+            echo $decoded->anything;              // no diagnostic — object allows any property
+        }
+
+        // Compound && condition: is_object() narrowing propagates
+        // through the entire condition and into the if-body.
+        $payload = json_decode('{}');             // mixed
+        if (is_object($payload) && property_exists($payload, 'name')) {
+            echo $payload->name;                  // no diagnostic
+        }
     }
 }
 

src/completion/resolver.rs

@@ -1063,6 +1063,24 @@ fn resolve_subject_outcome_variable(var_name: &str, ctx: &ResolutionCtx<'_>) ->
                 .map_or_else(|| joined.to_string(), |t| t.to_string());
             return SubjectOutcome::Scalar(display);
         }
+
+        // ── stdClass / object — synthetic resolution ────────────────
+        // `stdClass` and `object` are not loadable classes but they
+        // permit arbitrary property access.  Return a synthetic
+        // `Resolved(stdClass)` so the downstream member check
+        // (which already suppresses diagnostics for stdClass) kicks
+        // in instead of falling to `Untyped`.
+        if resolved.iter().any(|rt| {
+            matches!(&rt.type_string,
+                PhpType::Named(s) if s.eq_ignore_ascii_case("stdclass") || s == "object")
+        }) {
+            let synthetic = Arc::new(ClassInfo {
+                name: "stdClass".to_string(),
+                ..ClassInfo::default()
+            });
+            return SubjectOutcome::Resolved(vec![synthetic]);
+        }
+
         // The resolved types contain non-scalar, non-class entries
         // (e.g. type aliases we can't resolve).  Check for
         // unresolvable class names.

src/completion/types/narrowing.rs

@@ -1492,6 +1492,23 @@ fn apply_and_lhs_narrowing(
                         results,
                     );
                 }
+                return;
+            }
+
+            // Try type-guard functions (`is_object`, `is_array`, etc.).
+            // When `is_object($var)` appears in the LHS of `&&` and
+            // the variable has no resolved type yet, inject a synthetic
+            // `stdClass` so that downstream member-access diagnostics
+            // are suppressed (stdClass permits arbitrary properties).
+            if let Some((kind, negated)) = try_extract_type_guard(expr, ctx.var_name)
+                && !negated
+                && kind == TypeGuardKind::Object
+                && results.is_empty()
+            {
+                results.push(ClassInfo {
+                    name: "stdClass".to_string(),
+                    ..ClassInfo::default()
+                });
             }
         }
     }
@@ -2503,6 +2520,25 @@ enum TypeGuardKind {
     Callable,
 }
 
+/// Return the canonical `PhpType` that a type-guard narrows `mixed` to.
+///
+/// When a variable has type `mixed` and a type-guard like `is_object()`
+/// succeeds, the variable should narrow to `object` (not stay `mixed`
+/// and not become empty).  This function maps each guard kind to the
+/// PHP type it asserts.
+fn guard_kind_to_narrowed_type(kind: TypeGuardKind) -> PhpType {
+    match kind {
+        TypeGuardKind::Array => PhpType::Named("array".to_string()),
+        TypeGuardKind::String => PhpType::Named("string".to_string()),
+        TypeGuardKind::Int => PhpType::Named("int".to_string()),
+        TypeGuardKind::Float => PhpType::Named("float".to_string()),
+        TypeGuardKind::Bool => PhpType::Named("bool".to_string()),
+        TypeGuardKind::Object => PhpType::Named("object".to_string()),
+        TypeGuardKind::Numeric => PhpType::Named("numeric".to_string()),
+        TypeGuardKind::Callable => PhpType::Named("callable".to_string()),
+    }
+}
+
 /// Try to extract a type-guard function call on a variable.
 ///
 /// Matches `is_array($var)`, `is_string($var)`, etc. (with optional
@@ -2730,6 +2766,21 @@ fn filter_type_by_guard(ty: &PhpType, kind: TypeGuardKind, keep_matching: bool)
             }
         }
         other => {
+            // `mixed` includes all types.  When narrowing in the
+            // then-body (`keep_matching = true`), replace `mixed`
+            // with the canonical type for the guard kind (e.g.
+            // `is_object($mixed)` → `object`).  In the else-body
+            // (`keep_matching = false`), `mixed` minus one kind is
+            // still effectively `mixed`, so leave it unchanged.
+            if let PhpType::Named(name) = other
+                && name.eq_ignore_ascii_case("mixed")
+            {
+                return if keep_matching {
+                    Some(guard_kind_to_narrowed_type(kind))
+                } else {
+                    None // mixed minus one kind ≈ mixed
+                };
+            }
             // Non-union type: if it matches the predicate, keep it.
             if type_matches_guard(other, kind) == keep_matching {
                 None // no change needed
@@ -2755,6 +2806,21 @@ pub(in crate::completion) fn try_apply_type_guard_narrowing(
     if ctx.cursor_offset < body_span.start.offset || ctx.cursor_offset > body_span.end.offset {
         return;
     }
+
+    // ── Compound `&&` / `and` ───────────────────────────────────────
+    // `if (is_object($x) && is_string($y))` — both sides are true
+    // inside the then-body.  Decompose and apply each guard found.
+    if let Expression::Binary(bin) = condition
+        && matches!(
+            bin.operator,
+            BinaryOperator::And(_) | BinaryOperator::LowAnd(_)
+        )
+    {
+        try_apply_type_guard_narrowing(bin.lhs, body_span, ctx, results);
+        try_apply_type_guard_narrowing(bin.rhs, body_span, ctx, results);
+        return;
+    }
+
     if let Some((kind, negated)) = try_extract_type_guard(condition, ctx.var_name) {
         if negated {
             apply_type_guard_exclusion(kind, results);

src/diagnostics/unknown_members.rs

@@ -5255,4 +5255,94 @@ class OrderService {
             "expected no diagnostics for variable reassigned inside nested foreach loops, got: {diags:?}"
         );
     }
+
+    #[test]
+    fn no_diagnostic_for_object_parameter_type() {
+        let php = r#"<?php
+function test(object $obj): void {
+    echo $obj->anything;
+    $obj->whatever();
+}
+"#;
+        let backend = Backend::new_test();
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            diags.is_empty(),
+            "expected no diagnostics for object parameter type, got: {diags:?}"
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_after_is_object_guard() {
+        let php = r#"<?php
+function test(mixed $data): void {
+    if (is_object($data)) {
+        echo $data->error_link;
+    }
+}
+"#;
+        let backend = Backend::new_test();
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            diags.is_empty(),
+            "expected no diagnostics after is_object() guard, got: {diags:?}"
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_after_is_object_guard_with_negated_early_return() {
+        let php = r#"<?php
+function test(mixed $data): void {
+    if (!is_object($data)) {
+        return;
+    }
+    echo $data->error_link;
+    echo $data->something_else;
+    $data->doStuff();
+}
+"#;
+        let backend = Backend::new_test();
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            diags.is_empty(),
+            "expected no diagnostics after negated is_object() early return, got: {diags:?}"
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_after_is_object_in_compound_and_condition() {
+        let php = r#"<?php
+function test(mixed $data): void {
+    if (is_object($data) && property_exists($data, 'error_link') && is_string($data->error_link)) {
+        echo stripslashes($data->error_link);
+    }
+}
+"#;
+        let backend = Backend::new_test();
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            diags.is_empty(),
+            "expected no diagnostics after is_object() in compound && condition, got: {diags:?}"
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_object_typed_parameter() {
+        let php = r#"<?php
+function test(object $data): void {
+    echo $data->name;
+    $data->doStuff();
+}
+"#;
+        let backend = Backend::new_test();
+        backend.config.lock().diagnostics.unresolved_member_access = Some(true);
+        let diags = collect(&backend, "file:///test.php", php);
+        assert!(
+            diags.is_empty(),
+            "expected no diagnostics for object-typed parameter, got: {diags:?}"
+        );
+    }
 }