Merge pull request #200 from ryanbreen/feat/breenish-phase5-collections

feat: add Map, Set, do-while fix, and collection builtins

Author: ryanbreen

docs/planning/BREENISH_SHELL_PLAN.md

@@ -57,7 +57,9 @@
   - Tab completion for commands (PATH scan) and filenames (directory listing)
   - Nullish coalescing operator (??) with IsNullish opcode
   - Prefix/postfix increment/decrement operators (++/--)
-  - 162 passing tests, bsh v0.5.0 with full shell builtins
+  - Map and Set collections with full method support (get/set/has/delete/size/clear/keys/values/forEach)
+  - do...while loops with continue fix (deferred forward-jump patching)
+  - 182 passing tests, bsh v0.5.0 with full shell builtins
 - **Phase 6**: PLANNED -- Advanced features (class, Proxy, JIT)
 
 ## Architecture

libs/breenish-js/src/compiler.rs

@@ -37,6 +37,9 @@ struct LoopContext {
     break_jumps: Vec<usize>,
     /// The bytecode offset of the loop start (for continue).
     continue_target: usize,
+    /// Offsets of continue jumps that need patching (for do-while where
+    /// the continue target is not known until after body compilation).
+    continue_jumps: Vec<usize>,
 }
 
 /// Describes how a closure captures a variable.
@@ -389,6 +392,7 @@ impl<'a> Compiler<'a> {
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
             continue_target: loop_start,
+            continue_jumps: Vec::new(),
         });
 
         self.lexer.expect(&TokenKind::LeftParen)?;
@@ -480,6 +484,7 @@ impl<'a> Compiler<'a> {
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
             continue_target: increment_offset,
+            continue_jumps: Vec::new(),
         });
 
         self.compile_statement()?;
@@ -579,6 +584,7 @@ impl<'a> Compiler<'a> {
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
             continue_target: increment_offset,
+            continue_jumps: Vec::new(),
         });
 
         self.compile_statement()?;
@@ -679,6 +685,7 @@ impl<'a> Compiler<'a> {
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
             continue_target: increment_offset,
+            continue_jumps: Vec::new(),
         });
 
         self.compile_statement()?;
@@ -704,15 +711,19 @@ impl<'a> Compiler<'a> {
         let loop_start = self.code.current_offset();
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
-            continue_target: loop_start, // Will be updated
+            continue_target: usize::MAX, // Not yet known; continue_jumps will be patched
+            continue_jumps: Vec::new(),
         });
 
         self.compile_statement()?;
 
-        // continue target is the condition check
+        // continue target is the condition check; patch deferred continue jumps
         let condition_start = self.code.current_offset();
-        if let Some(ctx) = self.loop_stack.last_mut() {
-            ctx.continue_target = condition_start;
+        let continue_patches: Vec<usize> = self.loop_stack.last()
+            .map(|ctx| ctx.continue_jumps.clone())
+            .unwrap_or_default();
+        for cont in continue_patches {
+            self.code.patch_jump(cont, condition_start);
         }
 
         self.lexer.expect(&TokenKind::While)?;
@@ -760,6 +771,7 @@ impl<'a> Compiler<'a> {
         self.loop_stack.push(LoopContext {
             break_jumps: Vec::new(),
             continue_target: 0, // switch doesn't support continue
+            continue_jumps: Vec::new(),
         });
 
         // We need to save and restore the lexer position to do two passes.
@@ -1238,7 +1250,14 @@ impl<'a> Compiler<'a> {
             ));
         }
         let target = self.loop_stack.last().unwrap().continue_target;
-        self.code.emit_op_u16(Op::Jump, target as u16);
+        if target == usize::MAX {
+            // Continue target not yet known (do-while); emit a forward jump to be patched
+            let jump = self.code.emit_jump(Op::Jump);
+            self.loop_stack.last_mut().unwrap().continue_jumps.push(jump);
+        } else {
+            // Continue target is known (while/for); emit a direct backward jump
+            self.code.emit_op_u16(Op::Jump, target as u16);
+        }
         self.eat_semicolon();
         Ok(())
     }

libs/breenish-js/src/lib.rs

@@ -997,6 +997,32 @@ impl Context {
         self.vm.set_global_by_name("Number", JsValue::object(number_idx), &mut self.strings);
     }
 
+    /// Register built-in Map and Set collection constructors.
+    ///
+    /// This registers `Map()` and `Set()` as global factory functions that
+    /// create Map and Set objects respectively.
+    pub fn register_collection_builtins(&mut self) {
+        use crate::object::{JsObject, ObjectHeap};
+        use crate::string::StringPool as SP;
+        use crate::value::JsValue;
+        use crate::error::JsResult;
+
+        fn map_constructor(_args: &[JsValue], _strings: &mut SP, heap: &mut ObjectHeap) -> JsResult<JsValue> {
+            let obj = JsObject::new_map();
+            let idx = heap.alloc(obj);
+            Ok(JsValue::object(idx))
+        }
+
+        fn set_constructor(_args: &[JsValue], _strings: &mut SP, heap: &mut ObjectHeap) -> JsResult<JsValue> {
+            let obj = JsObject::new_set();
+            let idx = heap.alloc(obj);
+            Ok(JsValue::object(idx))
+        }
+
+        self.vm.register_native("Map", map_constructor);
+        self.vm.register_native("Set", set_constructor);
+    }
+
     /// Get a mutable reference to the string pool (for native functions).
     pub fn strings_mut(&mut self) -> &mut StringPool {
         &mut self.strings
@@ -2548,4 +2574,176 @@ mod tests {
             "10\n"
         );
     }
+
+    // --- do...while tests ---
+
+    #[test]
+    fn test_do_while() {
+        assert_eq!(
+            eval_and_capture("let i = 0; do { i++; } while (i < 5); print(i);"),
+            "5\n"
+        );
+    }
+
+    #[test]
+    fn test_do_while_runs_once() {
+        assert_eq!(
+            eval_and_capture("let i = 10; do { i++; } while (i < 5); print(i);"),
+            "11\n"
+        );
+    }
+
+    #[test]
+    fn test_do_while_with_break() {
+        assert_eq!(
+            eval_and_capture("let i = 0; do { i++; if (i === 3) break; } while (i < 10); print(i);"),
+            "3\n"
+        );
+    }
+
+    #[test]
+    fn test_do_while_with_continue() {
+        assert_eq!(
+            eval_and_capture("let sum = 0; let i = 0; do { i++; if (i % 2 === 0) continue; sum += i; } while (i < 6); print(sum);"),
+            "9\n"
+        );
+    }
+
+    // --- Map and Set tests ---
+
+    fn eval_collections(source: &str) -> String {
+        let mut ctx = Context::new();
+        ctx.set_print_fn(capture_print);
+        ctx.register_collection_builtins();
+        ctx.eval(source).unwrap();
+        take_output()
+    }
+
+    #[test]
+    fn test_map_basic() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('a', 1); m.set('b', 2); print(m.get('a'), m.get('b'));"),
+            "1 2\n"
+        );
+    }
+
+    #[test]
+    fn test_map_has_delete() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('x', 42); print(m.has('x')); m.delete('x'); print(m.has('x'));"),
+            "true\nfalse\n"
+        );
+    }
+
+    #[test]
+    fn test_map_size() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('a', 1); m.set('b', 2); print(m.size());"),
+            "2\n"
+        );
+    }
+
+    #[test]
+    fn test_map_overwrite() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('a', 1); m.set('a', 99); print(m.get('a')); print(m.size());"),
+            "99\n1\n"
+        );
+    }
+
+    #[test]
+    fn test_map_get_missing() {
+        assert_eq!(
+            eval_collections("let m = Map(); print(m.get('missing'));"),
+            "undefined\n"
+        );
+    }
+
+    #[test]
+    fn test_map_clear() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('a', 1); m.set('b', 2); m.clear(); print(m.size());"),
+            "0\n"
+        );
+    }
+
+    #[test]
+    fn test_map_keys_values() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('x', 10); m.set('y', 20); let k = m.keys(); let v = m.values(); print(k[0], k[1]); print(v[0], v[1]);"),
+            "x y\n10 20\n"
+        );
+    }
+
+    #[test]
+    fn test_map_numeric_keys() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set(1, 'one'); m.set(2, 'two'); print(m.get(1)); print(m.has(2));"),
+            "one\ntrue\n"
+        );
+    }
+
+    #[test]
+    fn test_map_chaining() {
+        assert_eq!(
+            eval_collections("let m = Map(); m.set('a', 1).set('b', 2).set('c', 3); print(m.size());"),
+            "3\n"
+        );
+    }
+
+    #[test]
+    fn test_set_basic() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(1); s.add(2); s.add(1); print(s.size()); print(s.has(1)); print(s.has(3));"),
+            "2\ntrue\nfalse\n"
+        );
+    }
+
+    #[test]
+    fn test_set_delete() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(42); s.delete(42); print(s.has(42));"),
+            "false\n"
+        );
+    }
+
+    #[test]
+    fn test_set_clear() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(1); s.add(2); s.add(3); s.clear(); print(s.size());"),
+            "0\n"
+        );
+    }
+
+    #[test]
+    fn test_set_values() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(10); s.add(20); s.add(30); let v = s.values(); print(v[0], v[1], v[2]);"),
+            "10 20 30\n"
+        );
+    }
+
+    #[test]
+    fn test_set_string_values() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add('hello'); s.add('world'); s.add('hello'); print(s.size()); print(s.has('hello')); print(s.has('missing'));"),
+            "2\ntrue\nfalse\n"
+        );
+    }
+
+    #[test]
+    fn test_set_chaining() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(1).add(2).add(3); print(s.size());"),
+            "3\n"
+        );
+    }
+
+    #[test]
+    fn test_set_delete_return() {
+        assert_eq!(
+            eval_collections("let s = Set(); s.add(1); print(s.delete(1)); print(s.delete(1));"),
+            "true\nfalse\n"
+        );
+    }
 }

libs/breenish-js/src/object.rs

@@ -37,6 +37,10 @@ pub enum ObjectKind {
     NativeFunction(u32),
     /// A Promise with its fulfillment state.
     Promise(PromiseState),
+    /// A Map object (ordered key-value pairs).
+    Map(Vec<(JsValue, JsValue)>),
+    /// A Set object (ordered unique values).
+    Set(Vec<JsValue>),
 }
 
 /// The state of a Promise.
@@ -132,6 +136,28 @@ impl JsObject {
         }
     }
 
+    /// Create a new Map object.
+    pub fn new_map() -> Self {
+        Self {
+            kind: ObjectKind::Map(Vec::new()),
+            properties: Vec::new(),
+            elements: Vec::new(),
+            prototype: None,
+            marked: false,
+        }
+    }
+
+    /// Create a new Set object.
+    pub fn new_set() -> Self {
+        Self {
+            kind: ObjectKind::Set(Vec::new()),
+            properties: Vec::new(),
+            elements: Vec::new(),
+            prototype: None,
+            marked: false,
+        }
+    }
+
     /// Create a new native function object.
     pub fn new_native_function(native_index: u32) -> Self {
         Self {
@@ -267,6 +293,17 @@ impl JsObject {
             }
             ObjectKind::Promise(PromiseState::Fulfilled(v)) => refs.push(*v),
             ObjectKind::Promise(PromiseState::Rejected(v)) => refs.push(*v),
+            ObjectKind::Map(ref entries) => {
+                for (k, v) in entries {
+                    refs.push(*k);
+                    refs.push(*v);
+                }
+            }
+            ObjectKind::Set(ref values) => {
+                for v in values {
+                    refs.push(*v);
+                }
+            }
             _ => {}
         }
         refs