Function check_scope

src/diagnostics/unused_variables.rs:175–340

Check a single scope for unused variables. `promoted_params` is `Some` when checking a method — it lists constructor promoted parameter names that should be skipped.

(
    scope: &ScopeMap,
    ctx: &mut DiagnosticCtx<'_>,
    promoted_params: Option<&HashSet<String>>,
    compact_vars: &HashSet<String>,
)

/// `promoted_params` is `Some` when checking a method — it lists
/// constructor promoted parameter names that should be skipped.
fn check_scope(
    scope: &ScopeMap,
    ctx: &mut DiagnosticCtx<'_>,
    promoted_params: Option<&HashSet<String>>,
    compact_vars: &HashSet<String>,
) {
    if scope.frames.is_empty() {
        return;
    }

    let always_skip: HashSet<&str> = {
        let mut set: HashSet<&str> = HashSet::new();
        for sg in SUPERGLOBALS {
            set.insert(sg);
        }
        set.insert("$this");
        set
    };

    // Build a set of parameter names for each nested frame so we can
    // exclude them from the parent frame's writes.  Closure and arrow
    // function parameters are written at offsets that are inside the
    // parent frame but outside the child frame body — the parent must
    // not claim them as its own writes.
    for frame in scope.frames.iter() {
        // Skip top-level frames — global scope has too many implicit defs.
        if frame.kind == FrameKind::TopLevel {
            continue;
        }

        // For catch frames, we only check the catch variable (which is
        // in frame.parameters).  We don't re-check variables inherited
        // from the parent — those are the parent frame's responsibility.
        // This avoids duplicate diagnostics.
        if frame.kind == FrameKind::Catch {
            // Before PHP 8.0, catch variables are mandatory syntax —
            // there is no way to omit them, so flagging them is noise.
            if ctx.php_version >= PhpVersion::new(8, 0) {
                check_catch_frame(frame, scope, ctx, &always_skip);
            }
            continue;
        }

        // Collect all variables written in this frame (directly, not
        // inside nested frames that create their own scope).
        let mut written_vars: HashMap<&str, u32> = HashMap::new();

        for access in &scope.accesses {
            if !matches!(access.kind, AccessKind::Write | AccessKind::ReadWrite) {
                continue;
            }
            if access.offset < frame.start || access.offset > frame.end {
                continue;
            }
            // Skip writes inside nested frames (closures, arrow fns,
            // catch blocks) — those belong to the child scope.
            if is_in_nested_frame(access.offset, frame, &scope.frames) {
                continue;