Function assignment_map_depth

src/completion/variable/forward_walk.rs:5806–5833

Compute the assignment dependency depth for a loop body. Does a cheap AST walk (no type resolution) to find which variables are assigned and which other variables appear on the RHS. Then follows the dependency chain to compute the longest path. For example, in: $a = $input; $b = transform($a); $c = $b + 1; The dependency map is {$a → {$input}, $b → {$a}, $c → {$b}} and the longest chain is 3 (

(statements: &[&Statement<'_>])

/// This determines how many loop iterations are needed for types to
/// propagate through the entire chain.  Typically 1-3 for real PHP.
fn assignment_map_depth(statements: &[&Statement<'_>]) -> u32 {
    // Build dependency map: assigned_var → set of RHS variables
    let mut deps: HashMap<String, HashSet<String>> = HashMap::new();

    for stmt in statements {
        collect_assignment_deps(stmt, &mut deps);
    }

    if deps.is_empty() {
        return 1;
    }

    // Compute longest dependency chain via DFS with cycle detection.
    let mut cache: HashMap<String, u32> = HashMap::new();
    let mut max_depth: u32 = 1;
    let keys: Vec<String> = deps.keys().cloned().collect();
    for key in &keys {
        let d = chain_depth(key, &deps, &mut cache, &mut HashSet::new());
        max_depth = max_depth.max(d);
    }

    // The chain depth tells us how many levels of variable-to-variable
    // propagation exist.  But even a single assignment needs 2 iterations:
    // one to discover the assignment, one to re-walk with the discovered
    // type visible from the start.  So: iterations = depth + 1.
    // Clamp to a reasonable maximum to avoid pathological cases.
    (max_depth + 1).min(3)
}

/// Recursively compute the dependency chain depth for a variable.
fn chain_depth(