hir: prealloc closure-capture boxes for lets nested in Try/If (array destructuring) (#5859)

compute_prealloc_for_hoisted_closures collects the function-entry
prealloc-box set via collect_top_level_let_ids_stmt, which only matched
top-level `Stmt::Let`. But array-destructuring bindings
(`let [a, b] = expr`) lower through the iterator protocol wrapped in a
`Try` (iterator close), so their leaf `let`s live inside the Try body /
its `if`s — never at the statement top level. A hoisted function
declaration capturing such a binding was therefore omitted from the
prealloc set: the closure captured the un-boxed, not-yet-assigned slot
and read `undefined` instead of the current value (e.g.
`const [k, setK] = useState(0)` captured by a hoisted handler — the
handler saw k === undefined and took the wrong branch).

Recurse into `Stmt::Try` (body/catch/finally) and `Stmt::If` (then/else)
— the constructs the destructuring lowering emits — when collecting
hoisted-let ids. Loops are intentionally not recursed: a per-iteration
`let` needs a fresh box per iteration, not a single function-entry
prealloc.

cargo test -p perry-hir: 221 passed, 0 failed.

Co-authored-by: Ralph Küpper <ralph@skelpo.com>

Author: proggeramlug

crates/perry-hir/src/lower_decl/block.rs

@@ -1351,8 +1351,54 @@ fn collect_refs_in_closure_bodies_expr(expr: &Expr, out: &mut std::collections::
 /// NOT recurse into nested blocks (those are block-scoped — their lets
 /// aren't hoisted to function-entry).
 pub fn collect_top_level_let_ids_stmt(stmt: &Stmt, out: &mut std::collections::HashSet<LocalId>) {
-    if let Stmt::Let { id, .. } = stmt {
-        out.insert(*id);
+    match stmt {
+        Stmt::Let { id, .. } => {
+            out.insert(*id);
+        }
+        // Array-destructuring bindings (`let [a, b] = it`) lower to the iterator
+        // protocol wrapped in a `Try` (see
+        // `destructuring::pattern_binding::lower_array_pattern_binding`), so the
+        // leaf `let`s live INSIDE the try body / its `if`s, not at the top level.
+        // Recurse into those so a hoisted FnDecl that captures a destructured var
+        // still gets its box preallocated at function entry. Without this, the
+        // hoisted closure captures the not-yet-assigned, unboxed slot and reads
+        // `undefined` — e.g. `const [K,_] = useState(0)` captured by a hoisted
+        // handler. Loops are intentionally NOT recursed: a per-iteration `let`
+        // needs a fresh box, not a single entry-prealloc.
+        Stmt::Try {
+            body,
+            catch,
+            finally,
+        } => {
+            for s in body {
+                collect_top_level_let_ids_stmt(s, out);
+            }
+            if let Some(c) = catch {
+                for s in &c.body {
+                    collect_top_level_let_ids_stmt(s, out);
+                }
+            }
+            if let Some(f) = finally {
+                for s in f {
+                    collect_top_level_let_ids_stmt(s, out);
+                }
+            }
+        }
+        Stmt::If {
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            for s in then_branch {
+                collect_top_level_let_ids_stmt(s, out);
+            }
+            if let Some(eb) = else_branch {
+                for s in eb {
+                    collect_top_level_let_ids_stmt(s, out);
+                }
+            }
+        }
+        _ => {}
     }
 }