@vibe-lang/runtime 0.2.5

package/src/runtime/test/binary-operators.test.ts

@@ -0,0 +1,431 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime, AIProvider } from '../index';
+
+// Mock AI provider
+function createMockProvider(): AIProvider {
+  return {
+    async execute() {
+      return { value: '' };
+    },
+    async generateCode() {
+      return { value: '' };
+    },
+    async askUser(): Promise<string> {
+      return '';
+    },
+  };
+}
+
+describe('Binary Operators - Arithmetic', () => {
+  test('addition: 1 + 2 = 3', async () => {
+    const ast = parse(`let result = 1 + 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3);
+  });
+
+  test('subtraction: 10 - 3 = 7', async () => {
+    const ast = parse(`let result = 10 - 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(7);
+  });
+
+  test('multiplication: 4 * 5 = 20', async () => {
+    const ast = parse(`let result = 4 * 5`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(20);
+  });
+
+  test('division: 20 / 4 = 5', async () => {
+    const ast = parse(`let result = 20 / 4`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(5);
+  });
+
+  test('modulo: 7 % 3 = 1', async () => {
+    const ast = parse(`let result = 7 % 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(1);
+  });
+
+  test('chained addition: 1 + 2 + 3 = 6', async () => {
+    const ast = parse(`let result = 1 + 2 + 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(6);
+  });
+
+  test('chained subtraction: 10 - 3 - 2 = 5', async () => {
+    const ast = parse(`let result = 10 - 3 - 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(5);
+  });
+
+  test('mixed add/subtract: 10 + 5 - 3 = 12', async () => {
+    const ast = parse(`let result = 10 + 5 - 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(12);
+  });
+
+  test('chained multiplication: 2 * 3 * 4 = 24', async () => {
+    const ast = parse(`let result = 2 * 3 * 4`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(24);
+  });
+
+  test('chained division: 100 / 2 / 5 = 10', async () => {
+    const ast = parse(`let result = 100 / 2 / 5`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(10);
+  });
+
+  test('negative result: 3 - 10 = -7', async () => {
+    const ast = parse(`let result = 3 - 10`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(-7);
+  });
+
+  test('decimal division: 7 / 2 = 3.5', async () => {
+    const ast = parse(`let result = 7 / 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3.5);
+  });
+});
+
+describe('Binary Operators - Precedence', () => {
+  test('multiplication before addition: 1 + 2 * 3 = 7', async () => {
+    const ast = parse(`let result = 1 + 2 * 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(7);
+  });
+
+  test('division before subtraction: 10 - 6 / 2 = 7', async () => {
+    const ast = parse(`let result = 10 - 6 / 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(7);
+  });
+
+  test('parentheses override: (1 + 2) * 3 = 9', async () => {
+    const ast = parse(`let result = (1 + 2) * 3`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(9);
+  });
+
+  test('nested parentheses: ((2 + 3) * 4) - 10 = 10', async () => {
+    const ast = parse(`let result = ((2 + 3) * 4) - 10`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(10);
+  });
+
+  test('complex expression: 2 + 3 * 4 - 6 / 2 = 11', async () => {
+    const ast = parse(`let result = 2 + 3 * 4 - 6 / 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(11);
+  });
+
+  test('modulo with addition: 10 % 3 + 5 = 6', async () => {
+    const ast = parse(`let result = 10 % 3 + 5`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(6);
+  });
+});
+
+describe('Binary Operators - Comparison', () => {
+  test('equality: 1 == 1 is true', async () => {
+    const ast = parse(`let result = 1 == 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('equality: 1 == 2 is false', async () => {
+    const ast = parse(`let result = 1 == 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('inequality: 1 != 2 is true', async () => {
+    const ast = parse(`let result = 1 != 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('inequality: 1 != 1 is false', async () => {
+    const ast = parse(`let result = 1 != 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('less than: 1 < 2 is true', async () => {
+    const ast = parse(`let result = 1 < 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('less than: 2 < 1 is false', async () => {
+    const ast = parse(`let result = 2 < 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('less than: 1 < 1 is false', async () => {
+    const ast = parse(`let result = 1 < 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('greater than: 2 > 1 is true', async () => {
+    const ast = parse(`let result = 2 > 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('greater than: 1 > 2 is false', async () => {
+    const ast = parse(`let result = 1 > 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('less than or equal: 1 <= 2 is true', async () => {
+    const ast = parse(`let result = 1 <= 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('less than or equal: 1 <= 1 is true', async () => {
+    const ast = parse(`let result = 1 <= 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('less than or equal: 2 <= 1 is false', async () => {
+    const ast = parse(`let result = 2 <= 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('greater than or equal: 2 >= 1 is true', async () => {
+    const ast = parse(`let result = 2 >= 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('greater than or equal: 1 >= 1 is true', async () => {
+    const ast = parse(`let result = 1 >= 1`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('greater than or equal: 1 >= 2 is false', async () => {
+    const ast = parse(`let result = 1 >= 2`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+});
+
+describe('Binary Operators - Comparison with Arithmetic', () => {
+  test('compare arithmetic results: 2 + 3 == 5 is true', async () => {
+    const ast = parse(`let result = 2 + 3 == 5`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('compare arithmetic results: 2 * 3 > 5 is true', async () => {
+    const ast = parse(`let result = 2 * 3 > 5`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('comparison in if condition', async () => {
+    const ast = parse(`
+let x = 10
+let result = "none"
+if x > 5 {
+  result = "big"
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe('big');
+  });
+
+  test('arithmetic comparison in if condition', async () => {
+    const ast = parse(`
+let a = 3
+let b = 4
+let result = "none"
+if a + b == 7 {
+  result = "correct"
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe('correct');
+  });
+});
+
+describe('Binary Operators - With Variables', () => {
+  test('add two variables', async () => {
+    const ast = parse(`
+let a = 5
+let b = 3
+let result = a + b
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(8);
+  });
+
+  test('multiply variable by constant', async () => {
+    const ast = parse(`
+let x = 7
+let result = x * 3
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(21);
+  });
+
+  test('complex expression with variables', async () => {
+    const ast = parse(`
+let a = 10
+let b = 5
+let c = 2
+let result = (a + b) * c - 10
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(20);
+  });
+
+  test('compare two variables', async () => {
+    const ast = parse(`
+let x = 10
+let y = 20
+let result = x < y
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+});
+
+describe('Binary Operators - String Equality', () => {
+  test('string equality: same strings', async () => {
+    const ast = parse(`let result = "hello" == "hello"`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('string equality: different strings', async () => {
+    const ast = parse(`let result = "hello" == "world"`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('string inequality', async () => {
+    const ast = parse(`let result = "hello" != "world"`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+});
+
+describe('Binary Operators - Boolean Equality', () => {
+  test('boolean equality: true == true', async () => {
+    const ast = parse(`let result = true == true`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+
+  test('boolean equality: true == false', async () => {
+    const ast = parse(`let result = true == false`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(false);
+  });
+
+  test('boolean inequality: true != false', async () => {
+    const ast = parse(`let result = true != false`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+});
+
+describe('Binary Operators - In Loops', () => {
+  test('arithmetic in for loop', async () => {
+    const ast = parse(`
+let sum = 0
+for i in 5 {
+  sum = sum + i
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    // 1 + 2 + 3 + 4 + 5 = 15
+    expect(runtime.getValue('sum')).toBe(15);
+  });
+
+  test('comparison in while loop', async () => {
+    const ast = parse(`
+let count = 0
+let max = 5
+while count < max {
+  count = count + 1
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('count')).toBe(5);
+  });
+
+  test('multiplication in loop accumulator', async () => {
+    const ast = parse(`
+let factorial = 1
+for i in 5 {
+  factorial = factorial * i
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    // 1 * 1 * 2 * 3 * 4 * 5 = 120
+    expect(runtime.getValue('factorial')).toBe(120);
+  });
+});

package/src/runtime/test/break-statement.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Break Statement Tests
+ *
+ * Tests for the break statement which exits the innermost loop.
+ */
+import { describe, test, expect } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState, runUntilPause, currentFrame } from '..';
+import { resolveValue } from '../types';
+
+describe('break statement', () => {
+  test('break exits for-in loop immediately', () => {
+    const source = `
+      let count = 0
+      for i in [1, 2, 3, 4, 5] {
+        if i == 3 {
+          break
+        }
+        count = count + 1
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const count = resolveValue(frame.locals['count']);
+    // Loop should have run for i=1, i=2, then break at i=3
+    expect(count).toBe(2);
+  });
+
+  test('break exits while loop immediately', () => {
+    const source = `
+      let count = 0
+      let i = 0
+      while i < 10 {
+        i = i + 1
+        if i == 5 {
+          break
+        }
+        count = count + 1
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const count = resolveValue(frame.locals['count']);
+    // Loop should have run for i=1,2,3,4, then break at i=5
+    expect(count).toBe(4);
+    const i = resolveValue(frame.locals['i']);
+    expect(i).toBe(5);
+  });
+
+  test('break only exits innermost loop (nested for-in)', () => {
+    const source = `
+      let outerCount = 0
+      let innerCount = 0
+      for i in [1, 2, 3] {
+        outerCount = outerCount + 1
+        for j in [1, 2, 3, 4, 5] {
+          if j == 2 {
+            break
+          }
+          innerCount = innerCount + 1
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const outerCount = resolveValue(frame.locals['outerCount']);
+    const innerCount = resolveValue(frame.locals['innerCount']);
+    // Outer loop runs 3 times
+    expect(outerCount).toBe(3);
+    // Inner loop breaks at j=2 each time, so only j=1 increments count = 1 per outer iteration
+    expect(innerCount).toBe(3);
+  });
+
+  test('break only exits innermost loop (nested while)', () => {
+    const source = `
+      let outerCount = 0
+      let innerCount = 0
+      let i = 0
+      while i < 3 {
+        i = i + 1
+        outerCount = outerCount + 1
+        let j = 0
+        while j < 10 {
+          j = j + 1
+          if j == 3 {
+            break
+          }
+          innerCount = innerCount + 1
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const outerCount = resolveValue(frame.locals['outerCount']);
+    const innerCount = resolveValue(frame.locals['innerCount']);
+    // Outer loop runs 3 times
+    expect(outerCount).toBe(3);
+    // Inner loop breaks at j=3 each time, so j=1,2 increment count = 2 per outer iteration
+    expect(innerCount).toBe(6);
+  });
+
+  test('break works in for-in inside while', () => {
+    const source = `
+      let result = 0
+      let i = 0
+      while i < 2 {
+        i = i + 1
+        for j in [10, 20, 30, 40] {
+          result = result + j
+          if j == 20 {
+            break
+          }
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const result = resolveValue(frame.locals['result']);
+    // Each outer iteration: 10 + 20 = 30 (break at 20)
+    // 2 outer iterations: 30 * 2 = 60
+    expect(result).toBe(60);
+  });
+
+  test('break works in while inside for-in', () => {
+    const source = `
+      let result = 0
+      for i in [1, 2] {
+        let j = 0
+        while j < 100 {
+          j = j + 1
+          result = result + 1
+          if j == 5 {
+            break
+          }
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const result = resolveValue(frame.locals['result']);
+    // Each outer iteration: while runs 5 times (j=1,2,3,4,5 then break)
+    // 2 outer iterations: 5 * 2 = 10
+    expect(result).toBe(10);
+  });
+
+  test('break as first statement in loop body', () => {
+    const source = `
+      let count = 0
+      for i in [1, 2, 3] {
+        break
+        count = count + 1
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const count = resolveValue(frame.locals['count']);
+    // Break immediately, count never incremented
+    expect(count).toBe(0);
+  });
+
+  test('break preserves variables declared before loop', () => {
+    const source = `
+      let x = 100
+      for i in [1, 2, 3, 4, 5] {
+        x = x + i
+        if i == 3 {
+          break
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const x = resolveValue(frame.locals['x']);
+    // x = 100 + 1 + 2 + 3 = 106 (break at i=3, after adding 3)
+    expect(x).toBe(106);
+  });
+
+  test('break cleans up loop variable scope', () => {
+    const source = `
+      let result = 0
+      for i in [1, 2, 3] {
+        let temp = i * 10
+        if i == 2 {
+          break
+        }
+        result = result + temp
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const result = resolveValue(frame.locals['result']);
+    // i=1: temp=10, result=10
+    // i=2: temp=20, break before adding
+    expect(result).toBe(10);
+    // temp should be cleaned up (not in frame.locals at top level)
+    expect(frame.locals['temp']).toBeUndefined();
+    // i should be cleaned up too
+    expect(frame.locals['i']).toBeUndefined();
+  });
+
+  test('conditional break with complex condition', () => {
+    const source = `
+      let sum = 0
+      for n in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] {
+        sum = sum + n
+        if sum > 15 {
+          break
+        }
+      }
+    `;
+    const program = parse(source);
+    let state = createInitialState(program);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = currentFrame(state);
+    const sum = resolveValue(frame.locals['sum']);
+    // 1+2+3+4+5 = 15, then 1+2+3+4+5+6 = 21 > 15, break
+    expect(sum).toBe(21);
+  });
+});