Faster diagnostics on method/function calls that resolve to no concrete

class

Author: AJenbo

docs/CHANGELOG.md

@@ -56,6 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Faster project startup.** The parts of startup that still ran on a single core now use all of them. Every autoload directory in the project, your own and each vendor package's, is walked in one pass that shares work between cores at the directory level, so a single very large dependency no longer holds up the rest of the scan, and the ignore rules above those directories are compiled once for the whole project instead of once per package. A bundled tool archive such as PHPStan's `.phar` is now read through a memory map with only its file index retained, rather than copied into memory whole. On a large Laravel project this cuts the indexing phase by roughly a quarter and lowers peak memory by around 25 MB. Discovered files are now sorted, so when two files declare the same class name the one that wins is the same on every run instead of depending on the order the filesystem happened to return.
 - **Class origin classification no longer re-scans the whole classmap after the fact.** Startup used to look up each discovered class's completion-ranking origin (project, explicit dependency, transitive dependency, core stub) by re-reading and re-parsing `installed.json` a second time and prefix-matching every class's file path against the package list on a single thread. The origin is now attached to a class the moment it is discovered during the already-parallel vendor scan, the same way it already worked for functions and constants, removing both the duplicate parse and the serial pass.
 - **Faster `assert()`/type-guard narrowing during the forward walk.** Every statement used to build a fresh resolution context (including a scope clone) for each in-scope variable to check whether it was an `assert()` or `@phpstan-assert`/`@psalm-assert` call, even for statements that could never be one. Non-call statements now skip that work entirely, cutting a measurable share of the walk on methods with many locals and many statements.
+- **Faster diagnostics on method/function calls that resolve to no concrete class.** Checking whether such a call's result was actually a bare `object`/`?object` (still valid for member access) used to re-resolve the callee's whole receiver chain and method signature a second time from scratch. That check now reuses the resolution already performed, roughly halving diagnostics time on files with many unresolved or missing-method call chains.
 
 ### Removed
 

docs/todo.md

@@ -201,7 +201,6 @@ unlikely to move the needle for most users.
 | P16 | [Pre-parsed stub format (eliminate raw PHP embedding)](todo/performance.md#p16-pre-parsed-stub-format-eliminate-raw-php-embedding)                                          | High        | Medium-High |
 | P25 | [`type_mismatch_argument` / `argument_count_mismatch` slow on large single files](todo/performance.md#p25-type_mismatch_argument-argument_count_mismatch-slow-on-large-single-files) | Medium      | Medium      |
 | P22 | [Signature change re-queues slow diagnostics for every open file](todo/performance.md#p22-signature-change-re-queues-slow-diagnostics-for-every-open-file)                  | Medium-High | Medium      |
-| P27 | [`object`/`?object` call-return check re-resolves the subject a second time](todo/performance.md#p27-objectobject-call-return-check-re-resolves-the-subject-a-second-time)  | Medium      | Low         |
 | P11 | [Uncached base-resolution in `build_scope_methods_for_builder`](todo/performance.md#p11-uncached-base-resolution-in-build_scope_methods_for_builder)                        | Low-Medium  | Low         |
 | P3  | Parallel pre-filter in `find_implementors`                                                                                                                                  | Low-Medium  | Medium      |
 | P6  | O(n²) transitive eviction in `evict_fqn`                                                                                                                                    | Low         | Low         |

docs/todo/performance.md

@@ -628,36 +628,6 @@ this item describes is still unaddressed.
 
 ---
 
-## P27. `object`/`?object` call-return check re-resolves the subject a second time
-
-**Impact: Medium · Effort: Low**
-
-`resolve_subject_outcome` resolves the whole subject up front (the
-`resolve_target_classes(subject, …)` call at the top). When that
-yields no concrete class, the `object`/`?object` escape-hatch branch
-then calls `resolve_call_raw_return_type(callee, "", ctx)` purely to
-peek at `is_object()`, and that helper re-resolves the callee's base
-chain from scratch. So every method/function call whose result has
-no concrete class pays a second full return-type resolution.
-
-This is exactly the shape of the `diagnostics/fixture/lots_of_missing_methods`
-benchmark (many calls whose results have missing members), and it
-regressed that fixture by ~29% (54ms → 70ms) when the branch was
-added, with a matching drift on hover and go-to-definition, which
-share this path.
-
-### Fix
-
-Fold the `object` detection into the primary resolution pass instead
-of running a separate re-resolution: when `resolve_target_classes`
-is about to return empty for a call subject, check whether the raw
-return type was `object`/`?object` at that point (the base chain is
-already resolved there) and emit the synthetic `stdClass` from the
-same pass. Do not pass `""` for the argument text on a second call;
-reuse the resolution already performed.
-
----
-
 ## P46. `mago-phpdoc-syntax` cannot parse `@method static (…) name()`
 
 **Impact: Low · Effort: Low (upstream)**

src/type_engine/resolver/mod.rs

@@ -376,10 +376,20 @@ fn resolve_target_classes_expr_inner(
             // Use the raw return type hint only when at least one
             // resolved class has template parameters — non-generic
             // classes don't benefit from it.
-            if let Some(h) = hint
-                && classes.iter().any(|c| !c.template_params.is_empty())
-            {
-                return ResolvedType::from_classes_with_hint(classes, h);
+            if let Some(h) = hint {
+                if classes.iter().any(|c| !c.template_params.is_empty()) {
+                    return ResolvedType::from_classes_with_hint(classes, h);
+                }
+                // `object`/`?object` is the "any object" escape hatch: no
+                // concrete class matches it, but the base chain and method
+                // lookup above have already determined that.  Surface it as
+                // a type-string-only candidate instead of dropping it, so
+                // callers that need to detect a bare `object` return (e.g.
+                // `resolve_subject_outcome`'s stdClass synthesis) don't have
+                // to re-resolve the callee's base chain a second time.
+                if classes.is_empty() && h.is_object() {
+                    return vec![ResolvedType::from_type_string(h)];
+                }
             }
 
             classes.into_iter().map(ResolvedType::from_arc).collect()
@@ -861,22 +871,10 @@ pub(crate) fn resolve_subject_outcome(
         if let Some(scalar) = resolve_call_scalar_return(callee, access_kind, ctx) {
             return SubjectOutcome::Scalar(scalar);
         }
-        // A call returning `object` (or `?object`) yields no concrete
-        // class, but `object` is the "any object" escape hatch: member
-        // access is always valid at runtime.  Resolve it to a synthetic
-        // `stdClass` so downstream verification treats it like the plain
-        // `object` property/parameter case, instead of reporting the
-        // subject type as unresolved.  `is_object()` unwraps nullability,
-        // so `?object` is handled here too.
-        if let Some(raw_type) = resolve_call_raw_return_type(callee, "", ctx)
-            && raw_type.is_object()
-        {
-            let synthetic = Arc::new(ClassInfo {
-                name: crate::atom::atom("stdClass"),
-                ..ClassInfo::default()
-            });
-            return SubjectOutcome::Resolved(vec![synthetic]);
-        }
+        // Note: a call returning `object`/`?object` is already caught by
+        // the "stdClass / object" check above — `resolve_target_classes`
+        // surfaces it as a type-string-only candidate instead of an empty
+        // result, so `resolved` would not have been empty in that case.
         // Try unresolvable class detection for function calls.
         if let SubjectExpr::FunctionCall(fn_name) = callee.as_ref()
             && let Some(fl) = ctx.function_loader

src/type_engine/variable/forward_walk/assignment.rs

@@ -2478,6 +2478,18 @@ pub(crate) fn process_assert_narrowing<'b>(
     scope: &mut ScopeState,
     ctx: &ForwardWalkCtx<'_>,
 ) {
+    // Every narrowing path below only fires for a (possibly parenthesized)
+    // call expression, so a non-call statement can never be an assert() /
+    // custom type-guard call. Bail out before the scope clone below, which
+    // otherwise runs once per in-scope variable for every statement.
+    let unwrapped = match expr {
+        Expression::Parenthesized(inner) => inner.expression,
+        other => other,
+    };
+    if !matches!(unwrapped, Expression::Call(_)) {
+        return;
+    }
+
     // ── Handle assert($x instanceof Foo) for variables NOT yet in scope ──
     // When a foreach binds a variable but the iterable element type is
     // unknown, the variable won't be in the scope map.  A subsequent