Function process_switch

src/completion/variable/forward_walk.rs:7303–7359

Process a `switch` statement. Each case arm is walked on a clone of the pre-switch scope so that assignments in one arm don't leak into another. After all arms are walked, the resulting scopes are merged (union of types), matching the runtime behaviour where only one arm executes. Fall-through cases (cases with no statements) share their scope with the next non-empty case, mirroring PHP semanti

(switch: &'b Switch<'b>, scope: &mut ScopeState, ctx: &ForwardWalkCtx<'_>)

/// Fall-through cases (cases with no statements) share their scope
/// with the next non-empty case, mirroring PHP semantics.
fn process_switch<'b>(switch: &'b Switch<'b>, scope: &mut ScopeState, ctx: &ForwardWalkCtx<'_>) {
    let pre_switch_scope = scope.clone();
    let cases: Vec<_> = switch.body.cases().iter().collect();

    if cases.is_empty() {
        return;
    }

    let mut branch_scopes: Vec<ScopeState> = Vec::new();
    let mut has_default = false;

    // Walk cases, accumulating fall-through groups.
    let mut accumulated_stmts: Vec<&Statement<'b>> = Vec::new();
    for case in &cases {
        if case.is_default() {
            has_default = true;
        }

        let stmts: Vec<_> = case.statements().iter().collect();
        if stmts.is_empty() {
            // Fall-through: no statements, will share scope with next case.
            continue;
        }

        accumulated_stmts.extend(stmts);

        let mut case_scope = pre_switch_scope.clone();
        walk_body_forward(accumulated_stmts.iter().copied(), &mut case_scope, ctx);
        branch_scopes.push(case_scope);
        accumulated_stmts.clear();
    }

    // Handle trailing fall-through cases (empty cases at the end).
    if !accumulated_stmts.is_empty() {
        let mut case_scope = pre_switch_scope.clone();
        walk_body_forward(accumulated_stmts.iter().copied(), &mut case_scope, ctx);
        branch_scopes.push(case_scope);
    }

    if branch_scopes.is_empty() {
        return;
    }

    // Merge all branch scopes.
    let mut merged = branch_scopes[0].clone();
    for s in &branch_scopes[1..] {
        merged.merge_branch(s);
    }

    // If there is no default case, the switch might not execute any
    // arm at all, so merge with the pre-switch scope.
    if !has_default {
        merged.merge_branch(&pre_switch_scope);
    }

    *scope = merged;
}