Merge pull request #199 from ryanbreen/feat/breenish-phase5-completion

feat: add tab completion, nullish coalescing, and increment/decrement

Author: ryanbreen

docs/planning/BREENISH_SHELL_PLAN.md

@@ -54,7 +54,10 @@
   - Interactive line editing: cursor movement, Home/End, Ctrl+A/E/U/K/W/C/D
   - Command history with Up/Down arrow navigation
   - Raw mode terminal handling via libbreenix termios
-  - 149 passing tests, bsh v0.5.0 with full shell builtins
+  - 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
 - **Phase 6**: PLANNED -- Advanced features (class, Proxy, JIT)
 
 ## Architecture

libs/breenish-js/src/bytecode.rs

@@ -197,6 +197,11 @@ pub enum Op {
     /// Used by for...in loops to iterate over object keys.
     GetKeys = 133,
 
+    /// Check if the top of stack is null or undefined.
+    /// Stack: [value] -> [boolean]
+    /// Pushes true (1) if null or undefined, false (0) otherwise.
+    IsNullish = 134,
+
     /// Halt execution.
     Halt = 255,
 }
@@ -254,6 +259,7 @@ impl Op {
             131 => Some(Op::Await),
             132 => Some(Op::WrapPromise),
             133 => Some(Op::GetKeys),
+            134 => Some(Op::IsNullish),
             255 => Some(Op::Halt),
             _ => None,
         }

libs/breenish-js/src/compiler.rs

@@ -78,6 +78,8 @@ pub struct Compiler<'a> {
     function_stack: Vec<FunctionContext>,
     /// Whether the current function being compiled is async.
     is_async: bool,
+    /// Tracks the last identifier compiled in compile_primary, for postfix ++/--.
+    last_primary_name: Option<String>,
 }
 
 impl<'a> Compiler<'a> {
@@ -96,6 +98,7 @@ impl<'a> Compiler<'a> {
             upvalues: Vec::new(),
             function_stack: Vec::new(),
             is_async: false,
+            last_primary_name: None,
         }
     }
 
@@ -1344,14 +1347,35 @@ impl<'a> Compiler<'a> {
     }
 
     fn compile_or(&mut self) -> JsResult<()> {
-        self.compile_and()?;
+        self.compile_nullish_coalesce()?;
 
         while self.lexer.peek().kind == TokenKind::Or {
             self.lexer.next_token();
             // Short-circuit: if truthy, skip RHS
             self.code.emit_op(Op::Dup);
             let skip = self.code.emit_jump(Op::JumpIfTrue);
             self.code.emit_op(Op::Pop);
+            self.compile_nullish_coalesce()?;
+            let end = self.code.current_offset();
+            self.code.patch_jump(skip, end);
+        }
+
+        Ok(())
+    }
+
+    fn compile_nullish_coalesce(&mut self) -> JsResult<()> {
+        self.compile_and()?;
+
+        while self.lexer.peek().kind == TokenKind::NullishCoalesce {
+            self.lexer.next_token();
+            // Nullish coalescing: if left is NOT nullish, keep it; otherwise use right.
+            // Stack: [left]
+            // Dup left, check IsNullish, if false (not nullish) jump over right side
+            self.code.emit_op(Op::Dup);
+            self.code.emit_op(Op::IsNullish);
+            let skip = self.code.emit_jump(Op::JumpIfFalse);
+            // Left is nullish: pop the duplicated left, compile right
+            self.code.emit_op(Op::Pop);
             self.compile_and()?;
             let end = self.code.current_offset();
             self.code.patch_jump(skip, end);
@@ -1556,13 +1580,30 @@ impl<'a> Compiler<'a> {
     fn compile_postfix(&mut self) -> JsResult<()> {
         self.compile_call()?;
 
-        // Postfix ++ and -- (Phase 1: handle simple identifier case)
+        // Postfix ++ and -- for simple identifiers
         if matches!(
             self.lexer.peek().kind,
             TokenKind::PlusPlus | TokenKind::MinusMinus
         ) {
-            // For Phase 1, just consume and ignore postfix ops on non-identifiers
-            self.lexer.next_token();
+            let is_increment = self.lexer.peek().kind == TokenKind::PlusPlus;
+            self.lexer.next_token(); // consume ++ or --
+
+            if let Some(name) = self.last_primary_name.take() {
+                // Stack currently has: [old_value]
+                // For postfix: the expression result is the OLD value.
+                // We need to: dup (keep old for expression result), add/sub 1, store back.
+                // Stack: [old_value]
+                self.code.emit_op(Op::Dup);          // [old_value, old_value]
+                let one = self.code.add_number(1.0);
+                self.code.emit_op_u16(Op::LoadConst, one); // [old_value, old_value, 1]
+                if is_increment {
+                    self.code.emit_op(Op::Add);       // [old_value, new_value]
+                } else {
+                    self.code.emit_op(Op::Sub);       // [old_value, new_value]
+                }
+                self.emit_store_var(&name);           // [old_value] (new_value stored)
+            }
+            // If not a simple identifier, postfix op is silently ignored (like before)
         }
 
         Ok(())
@@ -1573,6 +1614,13 @@ impl<'a> Compiler<'a> {
 
         // Handle postfix operations: calls, property access, indexing
         loop {
+            match &self.lexer.peek().kind {
+                TokenKind::LeftParen | TokenKind::Dot | TokenKind::LeftBracket => {
+                    // Any postfix operation invalidates the simple identifier tracking
+                    self.last_primary_name = None;
+                }
+                _ => {}
+            }
             match &self.lexer.peek().kind {
                 TokenKind::LeftParen => {
                     self.lexer.next_token(); // consume '('
@@ -1675,6 +1723,7 @@ impl<'a> Compiler<'a> {
     }
 
     fn compile_primary(&mut self) -> JsResult<()> {
+        self.last_primary_name = None;
         let tok = self.lexer.peek().clone();
         match &tok.kind {
             TokenKind::Number(n) => {
@@ -1782,6 +1831,7 @@ impl<'a> Compiler<'a> {
                     let idx = self.code.add_string(name_id.0);
                     self.code.emit_op_u16(Op::LoadGlobal, idx);
                 }
+                self.last_primary_name = Some(name);
                 Ok(())
             }
 
@@ -2099,6 +2149,19 @@ impl<'a> Compiler<'a> {
         }
     }
 
+    /// Emit code to store the top of stack into a variable (pops the value).
+    fn emit_store_var(&mut self, name: &str) {
+        if let Some((slot, _)) = self.resolve_local(name) {
+            self.code.emit_op_u16(Op::StoreLocal, slot);
+        } else if let Some(upval_idx) = self.resolve_upvalue(name) {
+            self.code.emit_op_u16(Op::StoreUpvalue, upval_idx);
+        } else {
+            let name_id = self.strings.intern(name);
+            let idx = self.code.add_string(name_id.0);
+            self.code.emit_op_u16(Op::StoreGlobal, idx);
+        }
+    }
+
     /// Emit code to store a value and leave it on the stack (for assignment expressions).
     fn emit_store_and_load_var(&mut self, name: &str) {
         if let Some((slot, _)) = self.resolve_local(name) {

libs/breenish-js/src/lib.rs

@@ -2434,4 +2434,118 @@ mod tests {
             "boolean\nboolean\n"
         );
     }
+
+    // --- Nullish coalescing tests ---
+
+    #[test]
+    fn test_nullish_coalescing() {
+        assert_eq!(
+            eval_and_capture("let a = null; print(a ?? 42);"),
+            "42\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_coalescing_non_null() {
+        assert_eq!(
+            eval_and_capture("let a = 10; print(a ?? 42);"),
+            "10\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_undefined() {
+        assert_eq!(
+            eval_and_capture("let a = undefined; print(a ?? \"default\");"),
+            "default\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_zero() {
+        // 0 is NOT nullish, so ?? should return 0
+        assert_eq!(
+            eval_and_capture("let a = 0; print(a ?? 42);"),
+            "0\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_empty_string() {
+        // Empty string is NOT nullish, so ?? should return ""
+        assert_eq!(
+            eval_and_capture("let a = \"\"; print(a ?? \"default\");"),
+            "\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_false() {
+        // false is NOT nullish, so ?? should return false
+        assert_eq!(
+            eval_and_capture("let a = false; print(a ?? true);"),
+            "false\n"
+        );
+    }
+
+    #[test]
+    fn test_nullish_chained() {
+        assert_eq!(
+            eval_and_capture("let a = null; let b = null; print(a ?? b ?? 99);"),
+            "99\n"
+        );
+    }
+
+    // --- Increment/Decrement tests ---
+
+    #[test]
+    fn test_prefix_increment() {
+        assert_eq!(
+            eval_and_capture("let x = 5; ++x; print(x);"),
+            "6\n"
+        );
+    }
+
+    #[test]
+    fn test_prefix_decrement() {
+        assert_eq!(
+            eval_and_capture("let x = 5; --x; print(x);"),
+            "4\n"
+        );
+    }
+
+    #[test]
+    fn test_prefix_increment_expression() {
+        // ++x returns the NEW value
+        assert_eq!(
+            eval_and_capture("let x = 5; let y = ++x; print(x, y);"),
+            "6 6\n"
+        );
+    }
+
+    #[test]
+    fn test_postfix_increment() {
+        // x++ returns the OLD value, but x is updated
+        assert_eq!(
+            eval_and_capture("let x = 5; let y = x++; print(x, y);"),
+            "6 5\n"
+        );
+    }
+
+    #[test]
+    fn test_postfix_decrement() {
+        // x-- returns the OLD value, but x is updated
+        assert_eq!(
+            eval_and_capture("let x = 5; let y = x--; print(x, y);"),
+            "4 5\n"
+        );
+    }
+
+    #[test]
+    fn test_increment_in_loop() {
+        assert_eq!(
+            eval_and_capture("let sum = 0; for (let i = 0; i < 5; i++) { sum += i; } print(sum);"),
+            "10\n"
+        );
+    }
 }

libs/breenish-js/src/vm.rs

@@ -586,6 +586,16 @@ impl Vm {
                     self.push(val)?;
                 }
 
+                Op::IsNullish => {
+                    let val = self.pop();
+                    let result = if val.is_nullish() {
+                        JsValue::boolean(true)
+                    } else {
+                        JsValue::boolean(false)
+                    };
+                    self.push(result)?;
+                }
+
                 Op::Print => {
                     let argc = self.read_u8_advance(code) as usize;