Function process_statement

src/completion/variable/forward_walk.rs:2942–3017

Process a single statement, updating `scope` with any variable assignments, narrowing, or control-flow effects.

(
    stmt: &'b Statement<'b>,
    scope: &mut ScopeState,
    ctx: &ForwardWalkCtx<'_>,
)

/// Process a single statement, updating `scope` with any variable
/// assignments, narrowing, or control-flow effects.
fn process_statement<'b>(
    stmt: &'b Statement<'b>,
    scope: &mut ScopeState,
    ctx: &ForwardWalkCtx<'_>,
) {
    match stmt {
        Statement::Expression(expr_stmt) => {
            process_expression_statement(expr_stmt, scope, ctx);
        }
        Statement::Foreach(foreach) => {
            process_foreach(foreach, scope, ctx);
        }
        Statement::If(if_stmt) => {
            process_if(if_stmt, stmt, scope, ctx);
        }
        Statement::While(while_stmt) => {
            process_while(while_stmt, scope, ctx);
        }
        Statement::For(for_stmt) => {
            process_for(for_stmt, scope, ctx);
        }
        Statement::DoWhile(dw) => {
            process_do_while(dw, scope, ctx);
        }
        Statement::Try(try_stmt) => {
            process_try(try_stmt, scope, ctx);
        }
        Statement::Switch(switch) => {
            process_switch(switch, scope, ctx);
        }
        Statement::Block(block) => {
            walk_body_forward(block.statements.iter(), scope, ctx);
        }
        Statement::Unset(unset_stmt) => {
            for val in unset_stmt.values.iter() {
                if let Expression::Variable(Variable::Direct(dv)) = val {
                    scope.remove(dv.name);
                }
            }
        }
        Statement::Namespace(ns) => {
            walk_body_forward(ns.statements().iter(), scope, ctx);
        }
        Statement::Global(global) => {
            for var in global.variables.iter() {
                if let Variable::Direct(dv) = var {
                    let var_name = dv.name.to_string();
                    if let Some(top_scope) = &ctx.top_level_scope {
                        if let Some(types) = top_scope.get(&atom(&var_name)) {
                            scope.set(&var_name, types.clone());
                        } else {
                            scope.set_empty(&var_name);
                        }
                    } else {
                        scope.set_empty(&var_name);
                    }
                }
            }