Function try_enter_closure_expr

src/completion/variable/forward_walk.rs:9147–9290

Recursively search an expression for a closure/arrow function containing the cursor.

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

/// Recursively search an expression for a closure/arrow function
/// containing the cursor.
fn try_enter_closure_expr<'b>(
    expr: &'b Expression<'b>,
    scope: &mut ScopeState,
    ctx: &ForwardWalkCtx<'_>,
    inferred_params: Option<&[PhpType]>,
) -> bool {
    match expr {
        Expression::Closure(closure) => {
            let body_span = closure.body.span();
            if ctx.cursor_offset >= body_span.start.offset
                && ctx.cursor_offset <= body_span.end.offset
            {
                // Create a fresh scope for the closure (closures have
                // isolated scope in PHP).
                let mut closure_scope = ScopeState::new();

                // PHP closures implicitly capture `$this` from the
                // enclosing class method.
                let this_types = 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 = 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 (mirroring the diagnostic path's
                // seed_closure_params logic).
                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,
                );

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

                // Replace the outer scope with the closure scope.
                *scope = closure_scope;
                return true;
            }
        }
        Expression::ArrowFunction(arrow) => {
            let body_span = arrow.expression.span();
            if ctx.cursor_offset >= body_span.start.offset