feat(bootstrap): Stage 6 — 4-slot environment, 4-deep let nesting

- Expand env from 2 slots (e0,e1) to 4 (e0..e3) supporting 4 nested lets
- Recursive env_lookup searches most-recent slot first for correct shadowing
- Closures still capture 1 binding (most recent) with existing 32-bit encoding
- New tests: 3-deep (a+b+c=6) and 4-deep (a+b+c+d=10) let nesting
- Update README to Stage 6

Author: dporkka

bootstrap/README.md

@@ -1,6 +1,6 @@
 # Nulang Self-Hosting Bootstrap
 
-> **Status:** Stage 5 — closures with environment capture working.
+> **Status:** Stage 6 — 4-slot environment, closures with 1-capture.
 > **Target:** A Nulang→Nulang compiler written in Nulang Core (RFC 0002)
 > that targets the `.nbc` format (RFC 0001).
 
@@ -26,7 +26,7 @@ source.nula
 
 ```bash
 nulang bootstrap/compiler_core.nula
-# Expected: 42, 7, 9, 43, 200, 6, 36, 11, 8, 7
+# Expected: 42, 7, 9, 43, 200, 6, 36, 11, 8, 7, 6, 10
 ```
 
 ## What's implemented
@@ -44,6 +44,12 @@ nulang bootstrap/compiler_core.nula
 - **Closure encoding:** 30-bit flag `1 << 30` in the high word of the 32-bit value; low 16 bits are the source position. Packed fields: flag | (ph << 23) | (body_start << 16) | (cap_hash << 8) | cap_value.
 - **Out-of-band sentinel:** `left == 1 << 40` replaces `left == 0` to distinguish "no left operand" from the valid expression result 0.
 
+### Stage 6 — 4-slot environment (2026-07-28)
+- **Environment:** expanded from 2 slots (e0, e1) to 4 slots (e0..e3), supporting up to 4 nested `let` bindings.
+- **Lookup:** recursive `env_lookup` searches most-recent slot first for correct shadowing.
+- **Closures:** still capture 1 binding (most recent), encoded as before in bits 8-15 of the closure tag.
+- **New tests:** `let a=1 in let b=2 in let c=3 in a+b+c` → 6, 4-deep → 10.
+
 ### Register spilling (2026-07-24)
 - Inline spilling (commit 06b03c6): no capacity limit.
 - Round-robin temp registers (commit db22c67): prevents clobbering in multi-operand spilled reads.
@@ -53,4 +59,4 @@ nulang bootstrap/compiler_core.nula
 - HM type inference
 - MIR lowering → `.nbc` codec
 - Self-compilation (`compiler_core.nula` → `compiler_core.nbc`)
-- Multi-binding environment capture (currently limited to 1 captured binding)
+- Multi-binding closure capture (closures still limited to 1 captured variable)

bootstrap/compiler_core.nula

@@ -1,7 +1,8 @@
-// bootstrap/compiler_core.nula — Stage 5: closures with env capture
+// bootstrap/compiler_core.nula — Stage 6: 4-slot env, 1-capture closures
 // Return: (value << 16) | pos.  Entry: (hash << 32) + value.
 // Closure encoding (32-bit): flag(bit30) | (ph<<23) | (bs<<16) | (cap_h<<8) | cap_v
 // flag = 1 << 30 = 1073741824. Position is clean source pos.
+// Env: e0..e3 with elen 0..4. let pushes to next slot. Closures capture most recent.
 
 fn is_digit(c: Int) -> Bool { c >= 48 and c <= 57 }
 fn is_alpha(c: Int) -> Bool { (c >= 65 and c <= 90) or (c >= 97 and c <= 122) }
@@ -34,23 +35,18 @@ fn read_ident(src: String, pos: Int, len: Int, h: Int) -> Int {
     }
 }
 
-fn env_lookup(e0: Int, e1: Int, elen: Int, h: Int) -> Int {
+// 4-slot environment lookup: search e3, e2, e1, e0 (most-recent first).
+fn env_lookup(e0: Int, e1: Int, e2: Int, e3: Int, elen: Int, h: Int) -> Int {
     if elen <= 0 then 0
-    else if elen >= 2 then {
-        let s1 = e1;
-        let h1 = s1 >> 32;
-        if h1 == h then s1 & 0xFFFFFFFF
-        else {
-            let s0 = e0;
-            let h0 = s0 >> 32;
-            if h0 == h then s0 & 0xFFFFFFFF
-            else 0
-        }
-    } else {
-        let s0 = e0;
-        let h0 = s0 >> 32;
-        if h0 == h then s0 & 0xFFFFFFFF
-        else 0
+    else {
+        // Check most recent slot first
+        let slot = if elen >= 4 then e3
+        else if elen >= 3 then e2
+        else if elen >= 2 then e1
+        else e0;
+        let sh = slot >> 32;
+        if sh == h then slot & 0xFFFFFFFF
+        else env_lookup(e0, e1, e2, 0, elen - 1, h)
     }
 }
 
@@ -60,7 +56,7 @@ fn prec_of(c: Int) -> Int {
     else 0
 }
 
-fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: Int, e1: Int, elen: Int) -> Int {
+fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: Int, e1: Int, e2: Int, e3: Int, elen: Int) -> Int {
     let no_left = 1 << 40;
     let pair = if left == no_left then {
         let p = skip_ws(src, pos, len);
@@ -69,7 +65,7 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
             let c = perform String.charAt(src, p);
             if is_digit(c) then read_int(src, p, len, 0)
             else if c == 40 then {
-                let inner = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, elen);
+                let inner = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, e2, e3, elen);
                 let v = inner >> 16;
                 let q = inner & 0xFFFF;
                 let q2 = skip_ws(src, q, len);
@@ -83,6 +79,7 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                 let h = ident >> 16;
                 let q = ident & 0xFFFF;
                 if h == 3321 then {
+                    // "let" keyword
                     let q2 = skip_ws(src, q, len);
                     let var_id = read_ident(src, q2, len, 0);
                     let vh = var_id >> 16;
@@ -91,7 +88,7 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                     if q4 < len then {
                         let c3 = perform String.charAt(src, q4);
                         if c3 == 61 then {
-                            let bound = parse_pratt(src, q4 + 1, len, no_left, 0, e0, e1, elen);
+                            let bound = parse_pratt(src, q4 + 1, len, no_left, 0, e0, e1, e2, e3, elen);
                             let bv = bound >> 16;
                             let bp = bound & 0xFFFF;
                             let bp2 = skip_ws(src, bp, len);
@@ -101,21 +98,26 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                                 if ci == 105 and cn == 110 then {
                                     let entry = (vh << 32) + bv;
                                     if elen == 0 then {
-                                        parse_pratt(src, bp2 + 2, len, no_left, 0, entry, e1, 1)
+                                        parse_pratt(src, bp2 + 2, len, no_left, 0, entry, 0, 0, 0, 1)
+                                    } else if elen == 1 then {
+                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, entry, 0, 0, 2)
+                                    } else if elen == 2 then {
+                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, e1, entry, 0, 3)
                                     } else {
-                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, entry, 2)
+                                        parse_pratt(src, bp2 + 2, len, no_left, 0, e0, e1, e2, entry, 4)
                                     }
                                 } else (bv << 16) + bp2
                             } else (bv << 16) + bp2
                         } else {
-                            let v = env_lookup(e0, e1, elen, h);
+                            let v = env_lookup(e0, e1, e2, e3, elen, h);
                             (v << 16) + q
                         }
                     } else {
-                        let v = env_lookup(e0, e1, elen, h);
+                        let v = env_lookup(e0, e1, e2, e3, elen, h);
                         (v << 16) + q
                     }
                 } else if h == 620 then {
+                    // "fn" keyword
                     let q2 = skip_ws(src, q, len);
                     if q2 < len then {
                         let c1 = perform String.charAt(src, q2);
@@ -134,12 +136,15 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                                         let c4 = perform String.charAt(src, q6 + 1);
                                         if c3 == 61 and c4 == 62 then {
                                             let body_start = q6 + 2;
-                                            let body_parsed = parse_pratt(src, body_start, len, no_left, 0, e0, e1, elen);
+                                            let body_parsed = parse_pratt(src, body_start, len, no_left, 0, e0, e1, e2, e3, elen);
                                             let body_end = body_parsed & 0xFFFF;
                                             let flag = 1 << 30;
                                             let enc = flag + (ph << 23) + (((body_start & 0x7F) << 16));
                                             let cap_data = if elen > 0 then {
-                                                let cap_e = if elen >= 2 then e1 else e0;
+                                                let cap_e = if elen >= 4 then e3
+                                                else if elen >= 3 then e2
+                                                else if elen >= 2 then e1
+                                                else e0;
                                                 let cap_h = (cap_e >> 32) & 0xFF;
                                                 let cap_v = cap_e & 0xFFFF;
                                                 (cap_h << 16) + cap_v
@@ -155,7 +160,7 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                         } else (0 << 16) + p
                     } else (0 << 16) + p
                 } else {
-                    let v = env_lookup(e0, e1, elen, h);
+                    let v = env_lookup(e0, e1, e2, e3, elen, h);
                     (v << 16) + q
                 }
             } else (0 << 16) + p
@@ -171,7 +176,7 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
     else {
         let c = perform String.charAt(src, p);
         if c == 40 then {
-            let arg = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, elen);
+            let arg = parse_pratt(src, p + 1, len, no_left, 0, e0, e1, e2, e3, elen);
             let av = arg >> 16;
             let ap = arg & 0xFFFF;
             let ap2 = skip_ws(src, ap, len);
@@ -185,23 +190,23 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                         let cap_v = lv & 0xFF;
                         let entry_param = (ph << 32) + av;
                         if cap_h == 0 then {
-                            parse_pratt(src, bs, len, no_left, 0, entry_param, 0, 1)
+                            parse_pratt(src, bs, len, no_left, 0, entry_param, 0, 0, 0, 1)
                         } else {
                             let entry_cap = (cap_h << 32) + cap_v;
-                            parse_pratt(src, bs, len, no_left, 0, entry_cap, entry_param, 2)
+                            parse_pratt(src, bs, len, no_left, 0, entry_cap, entry_param, 0, 0, 2)
                         }
                     } else {
                         (lv << 16) + ap2
                     };
                     let rv = result >> 16;
-                    parse_pratt(src, ap2 + 1, len, rv, min_prec, e0, e1, elen)
+                    parse_pratt(src, ap2 + 1, len, rv, min_prec, e0, e1, e2, e3, elen)
                 } else pair
             } else pair
         } else {
             let prec = prec_of(c);
             if prec == 0 or prec < min_prec then pair
             else {
-                let rhs = parse_pratt(src, p + 1, len, no_left, prec, e0, e1, elen);
+                let rhs = parse_pratt(src, p + 1, len, no_left, prec, e0, e1, e2, e3, elen);
                 let rv = rhs >> 16;
                 let rp = rhs & 0xFFFF;
                 let result = if c == 43 then lv + rv
@@ -210,15 +215,15 @@ fn parse_pratt(src: String, pos: Int, len: Int, left: Int, min_prec: Int, e0: In
                 else if c == 47 then {
                     if rv == 0 then lv else lv / rv
                 } else lv;
-                parse_pratt(src, rp, len, result, min_prec, e0, e1, elen)
+                parse_pratt(src, rp, len, result, min_prec, e0, e1, e2, e3, elen)
             }
         }
     }
 }
 
 fn parse(src: String) -> Int {
     let len = perform String.length(src);
-    let result = parse_pratt(src, 0, len, 1 << 40, 0, 0, 0, 0);
+    let result = parse_pratt(src, 0, len, 1 << 40, 0, 0, 0, 0, 0, 0);
     result >> 16
 }
 
@@ -233,4 +238,7 @@ fn main() {
     perform IO.print(parse("let f = fn(x) => x + 1 in f(10)"))
     perform IO.print(parse("let a = 3 in (fn(x) => a + x)(5)"))
     perform IO.print(parse("let add = fn(a) => fn(b) => a + b in add(3)(4)"))
+    // New tests: 3- and 4-deep let bindings
+    perform IO.print(parse("let a = 1 in let b = 2 in let c = 3 in a + b + c"))
+    perform IO.print(parse("let a = 1 in let b = 2 in let c = 3 in let d = 4 in a + b + c + d"))
 }