Function walk_closures_in_expr

src/completion/variable/forward_walk.rs:433–626

Recursively scan an expression tree for closures/arrow functions and walk their bodies with properly seeded scopes. When a closure/arrow function is found: 1. Build a scope for the closure body (fresh for closures, cloned from outer for arrow functions). 2. Seed the scope with parameter types (using callable inference from the enclosing call's signature when parameters are untyped). 3. Walk the b

(
    expr: &'b Expression<'b>,
    outer_scope: &ScopeState,
    ctx: &ForwardWalkCtx<'_>,
    inferred_params: Option<&[PhpType]>,
)

/// passes the inferred types so untyped parameters get the correct
/// types.
fn walk_closures_in_expr<'b>(
    expr: &'b Expression<'b>,
    outer_scope: &ScopeState,
    ctx: &ForwardWalkCtx<'_>,
    inferred_params: Option<&[PhpType]>,
) {
    match expr {
        Expression::Closure(closure) => {
            // Build a fresh scope for the closure.
            let mut closure_scope = ScopeState::new();

            // PHP closures implicitly capture `$this` from the
            // enclosing class method.  Seed it from the outer scope
            // so that `$this->prop` inside the closure resolves
            // without calling `resolve_variable_types`.
            let this_types = outer_scope.get("$this");
            if !this_types.is_empty() {
                closure_scope.set("$this", this_types.to_vec());
            }

            // Seed with `use(...)` variables from the outer scope.
            if let Some(ref use_clause) = closure.use_clause {
                for use_var in use_clause.variables.iter() {
                    let var_name = use_var.variable.name.to_string();
                    let from_outer = outer_scope.get(&var_name);
                    if !from_outer.is_empty() {
                        closure_scope.set(&var_name, from_outer.to_vec());
                    }
                }
            }

            // Seed with parameter types, using callable inference when
            // available.  Filter out any inferred params whose base
            // type is unresolvable (e.g. PHPStan pseudo-types like
            // `collection-of<T>`) so they don't poison the scope —
            // the param simply won't be seeded, which is better than
            // skipping the entire closure body.
            let inferred = inferred_params.unwrap_or(&[]);
            let filtered_inferred = filter_resolvable_inferred_params(inferred, ctx);
            seed_closure_params(
                &mut closure_scope,
                &closure.parameter_list,
                closure.span().start.offset,
                &filtered_inferred,
                ctx,
            );

            // Record the scope at the body start.
            let body_span = closure.body.span();
            record_scope_snapshot(body_span.start.offset, &closure_scope);

            // Walk the closure body.
            walk_body_for_diagnostics(closure.body.statements.iter(), &mut closure_scope, ctx);

            // Record at body end (closure scope).
            record_scope_snapshot(body_span.end.offset, &closure_scope);

            // Restore the outer scope immediately after the closure body