Function resolve_target_classes_expr

src/completion/resolver.rs:347–415

Core dispatch for [`resolve_target_classes`], operating on a pre-parsed [`SubjectExpr`].

(
    expr: &SubjectExpr,
    access_kind: AccessKind,
    ctx: &ResolutionCtx<'_>,
)

/// Core dispatch for [`resolve_target_classes`], operating on a
/// pre-parsed [`SubjectExpr`].
pub(crate) fn resolve_target_classes_expr(
    expr: &SubjectExpr,
    access_kind: AccessKind,
    ctx: &ResolutionCtx<'_>,
) -> Vec<ResolvedType> {
    // ── Chain cache lookup ───────────────────────────────────────
    // During diagnostic passes the chain cache is active and stores
    // results by subject text.  This eliminates O(depth²) re-resolution
    // of shared chain prefixes (e.g. `$model->where(...)` resolved once
    // and reused by `$model->where(...)->whereNotNull(...)` etc.).
    //
    // The cache is NOT used for variable-only subjects (no `->` or `::`
    // in the expression) because those are context-sensitive: the same
    // `$var` may resolve to different types at different cursor offsets
    // due to reassignment or narrowing.
    //
    // PropertyChain expressions rooted in a variable (e.g. `$this->pet`,
    // `$obj->prop`) are also excluded because instanceof narrowing can
    // change the resolved type at different positions within the same
    // method body.  For example, `$this->pet` may resolve to `Dog`
    // inside `if ($this->pet instanceof Dog)` but to `Cat` after
    // `if (!$this->pet instanceof Cat) { return; }`.
    //
    // Call expressions and static accesses are safe to cache because
    // their return types are deterministic (method signatures don't
    // change based on narrowing context).
    let is_cacheable_chain = match expr {
        SubjectExpr::CallExpr { .. }
        | SubjectExpr::MethodCall { .. }
        | SubjectExpr::StaticMethodCall { .. }
        | SubjectExpr::StaticAccess { .. } => true,
        // PropertyChain is only cacheable when the base is NOT a
        // bare variable — e.g. `$this->method()->prop` (CallExpr
        // base) is safe, but `$this->pet` (This/Variable base) is
        // subject to narrowing.
        SubjectExpr::PropertyChain { base, .. } => !matches!(
            base.as_ref(),
            SubjectExpr::This
                | SubjectExpr::SelfKw
                | SubjectExpr::StaticKw
                | SubjectExpr::Parent
                | SubjectExpr::Variable(_)
        ),
        _ => false,
    };
    if is_cacheable_chain {
        let cache_key = expr.to_subject_text();
        let cached = CHAIN_CACHE.with(|cell| {
            let borrow = cell.borrow();
            borrow.as_ref().and_then(|map| map.get(&cache_key).cloned())
        });
        if let Some(result) = cached {
            return result;
        }

        let result = resolve_target_classes_expr_inner(expr, access_kind, ctx);

        CHAIN_CACHE.with(|cell| {