Chore: Implement IT.

Author: dylan-sutton-chavez

compiler/src/modules/parser/expr.rs

@@ -367,6 +367,14 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                         self.chunk.emit(OpCode::GetItem, 0);
                     } else {
                         self.eat(TokenType::Rsqb);
+                        // Chained subscript assignment: a[i][j] = v
+                        if !is_slice && matches!(self.peek(), Some(TokenType::Equal)) {
+                            self.advance();
+                            self.expr();
+                            self.chunk.emit(OpCode::StoreItem, 0);
+                            self.chunk.emit(OpCode::LoadNone, 0);
+                            return;
+                        }
                         self.chunk.emit(OpCode::GetItem, 0);
                     }
                 }

compiler/src/modules/parser/stmt.rs

@@ -123,7 +123,17 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                 false
             }
             Some(TokenType::Nonlocal) => {
-                self.emit_name_list(OpCode::Nonlocal);
+                self.advance();
+                loop {
+                    let t = self.advance();
+                    let name = self.lexeme(&t).to_string();
+                    let idx = self.chunk.push_name(&name);
+                    self.chunk.emit(OpCode::Nonlocal, idx);
+                    if !self.chunk.nonlocals.contains(&name) {
+                        self.chunk.nonlocals.push(name);
+                    }
+                    if !self.eat_if(TokenType::Comma) { break; }
+                }
                 false
             }
             Some(TokenType::Assert) => {

compiler/src/modules/parser/types.rs

@@ -103,6 +103,7 @@ pub struct SSAChunk {
     pub overflow: bool,
     pub prev_slots: Vec<Option<u16>>,
     pub phi_map: Vec<usize>,
+    pub nonlocals: Vec<String>,
     pub(super) name_index: HashMap<String, u16>
 }
 

compiler/src/modules/vm/handlers/function.rs

@@ -111,11 +111,29 @@ impl<'a> VM<'a> {
             HashMap::with_capacity_and_hasher(body.names.len(), Default::default());
         for (i, n) in body.names.iter().enumerate() { body_map.insert(n.as_str(), i); }
 
-        for (i, param) in params.iter().enumerate() {
-            if i >= positional.len() { break; }
-            let pname = format!("{}_0", param.trim_start_matches('*'));
-            if let Some(&s) = body_map.get(pname.as_str()) {
-                fn_slots[s] = Some(positional[i]);
+        let mut pos_idx = 0usize;
+        for param in params.iter() {
+            if let Some(star_name) = param.strip_prefix("**") {
+                // **kwargs: not yet supported, skip
+                let _ = star_name;
+            } else if let Some(var_name) = param.strip_prefix('*') {
+                // *args: collect all remaining positionals into a list
+                let rest: Vec<Val> = positional[pos_idx..].to_vec();
+                pos_idx = positional.len();
+                let list_val = self.heap.alloc(
+                    HeapObj::List(Rc::new(RefCell::new(rest)))
+                )?;
+                let pname = format!("{}_0", var_name);
+                if let Some(&s) = body_map.get(pname.as_str()) {
+                    fn_slots[s] = Some(list_val);
+                }
+            } else {
+                if pos_idx >= positional.len() { continue; }
+                let pname = format!("{}_0", param);
+                if let Some(&s) = body_map.get(pname.as_str()) {
+                    fn_slots[s] = Some(positional[pos_idx]);
+                }
+                pos_idx += 1;
             }
         }
 
@@ -183,13 +201,37 @@ impl<'a> VM<'a> {
         self.live_slots.extend(slots.iter().flatten().copied());
         self.observed_impure.push(false);
 
-        // Capturar el Result; cleanup corre incondicionalmente antes de propagar Err.
         let exec_result = self.exec(body, &mut fn_slots);
 
         let callee_impure = self.observed_impure.pop().unwrap_or(true);
         self.live_slots.truncate(snap);
         self.depth -= 1;
 
+        // Write back nonlocal variables to the caller's slots.
+        for base in &body.nonlocals {
+            // Find the highest-versioned value in the callee's slots.
+            let best = body.names.iter().enumerate()
+                .filter_map(|(i, n)| {
+                    let p = n.rfind('_')?;
+                    (n[..p] == **base).then_some(())?;
+                    let ver: u32 = n[p+1..].parse().ok()?;
+                    Some((ver, fn_slots[i]?))
+                })
+                .max_by_key(|(ver, _)| *ver)
+                .map(|(_, val)| val);
+
+            if let Some(val) = best {
+                // Update all versions of this name in the caller's slots.
+                for (si, sname) in chunk.names.iter().enumerate() {
+                    if let Some(p) = sname.rfind('_') {
+                        if &sname[..p] == base.as_str() && si < slots.len() {
+                            slots[si] = Some(val);
+                        }
+                    }
+                }
+            }
+        }
+
         let result = exec_result?;
         if callee_impure { self.mark_impure(); }
 

compiler/src/modules/vm/ops.rs

@@ -276,12 +276,28 @@ impl<'a> VM<'a> {
         if let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b)) {
             return self.bigint_to_val(ba.mul(&bb));
         }
-        let (str_val, count) = if a.is_heap() && b.is_int() { (a, b.as_int()) }
-                            else if a.is_int() && b.is_heap() { (b, a.as_int()) }
-                            else { return Err(VmErr::Type("unsupported operand type(s) for '*'")); };
-        if let HeapObj::Str(s) = self.heap.get(str_val) {
-            let r = s.repeat(count.max(0) as usize);
-            return self.heap.alloc(HeapObj::Str(r));
+        let (seq_val, count) = if a.is_heap() && b.is_int() { (a, b.as_int()) }
+                else if a.is_int() && b.is_heap() { (b, a.as_int()) }
+                else { return Err(VmErr::Type("unsupported operand type(s) for '*'")); };
+        let n = count.max(0) as usize;
+        match self.heap.get(seq_val) {
+            HeapObj::Str(s) => {
+                let r = s.repeat(n);
+                return self.heap.alloc(HeapObj::Str(r));
+            }
+            HeapObj::List(rc) => {
+                let src = rc.borrow().clone();
+                let mut out = Vec::with_capacity(src.len() * n);
+                for _ in 0..n { out.extend_from_slice(&src); }
+                return self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(out))));
+            }
+            HeapObj::Tuple(v) => {
+                let src = v.clone();
+                let mut out = Vec::with_capacity(src.len() * n);
+                for _ in 0..n { out.extend_from_slice(&src); }
+                return self.heap.alloc(HeapObj::Tuple(out));
+            }
+            _ => {}
         }
         Err(VmErr::Type("unsupported operand type(s) for '*'"))
     }

compiler/tests/cases/vm.json

@@ -370,5 +370,9 @@
   {"src": "d = {'a':1}\nprint(d.get('a'))", "output": ["1"], "result": "None"},
   {"src": "d = {'a':1}\nprint(d.get('z', 0))", "output": ["0"], "result": "None"},
   {"src": "d = {'a':1,'b':2}\nd.update({'b':9,'c':3})\nprint(d)", "output": ["{'a': 1, 'b': 9, 'c': 3}"], "result": "None"},
-  {"src": "d = {'a':1}\nd.pop('a')\nprint(d)", "output": ["{}"], "result": "None"}
+  {"src": "d = {'a':1}\nd.pop('a')\nprint(d)", "output": ["{}"], "result": "None"},
+  {"src": "for i in range(3):\n    if i == 1:\n        break\nelse:\n    print('done')\nprint('end')", "output": ["end"], "result": "None"},
+  {"src": "def outer():\n    x = 0\n    def inner():\n        nonlocal x\n        x += 1\n    inner()\n    inner()\n    return x\nprint(outer())", "output": ["2"], "result": "None"},
+  {"src": "def f(*args):\n    return sum(args)\nprint(f(1,2,3))", "output": ["6"], "result": "None"},
+  {"src": "matrix = [[0]*3 for _ in range(3)]\nmatrix[1][1] = 5\nprint(matrix[1][1])", "output": ["5"], "result": "None"}
 ]