@vibe-lang/runtime 0.2.5

package/src/semantic/test/control-flow.test.ts

@@ -0,0 +1,346 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Control Flow', () => {
+  // ============================================================================
+  // Return outside function
+  // ============================================================================
+
+  test('return at top level', () => {
+    const ast = parse(`
+return "hello"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('return outside of function');
+  });
+
+  test('return in if block at top level', () => {
+    const ast = parse(`
+if true {
+  return "hello"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('return outside of function');
+  });
+
+  test('return in else block at top level', () => {
+    const ast = parse(`
+if false {
+  let x = "no"
+} else {
+  return "hello"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('return outside of function');
+  });
+
+  test('return in nested blocks at top level', () => {
+    const ast = parse(`
+if true {
+  if true {
+    return "hello"
+  }
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('return outside of function');
+  });
+
+  // ============================================================================
+  // Valid return statements
+  // ============================================================================
+
+  test('return inside function', () => {
+    const ast = parse(`
+function test() {
+  return "hello"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return inside if block in function', () => {
+    const ast = parse(`
+function test(x: boolean): text {
+  if x {
+    return "yes"
+  }
+  return "no"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return inside else block in function', () => {
+    const ast = parse(`
+function test(x: boolean): text {
+  if x {
+    return "yes"
+  } else {
+    return "no"
+  }
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return inside nested blocks in function', () => {
+    const ast = parse(`
+function test(x: boolean): text {
+  if x {
+    if true {
+      return "deep"
+    }
+  }
+  return "default"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // If condition type checking
+  // ============================================================================
+
+  test('if with non-boolean literal condition errors', () => {
+    const ast = parse(`
+if "test" {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('if condition must be boolean, got text');
+  });
+
+  test('if with non-boolean typed variable condition errors', () => {
+    const ast = parse(`
+const x: text = "test"
+if x {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('if condition must be boolean, got text');
+  });
+
+  test('if with number literal condition errors', () => {
+    const ast = parse(`
+if 5 {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('if condition must be boolean, got number');
+  });
+
+  test('if with boolean literal condition passes', () => {
+    const ast = parse(`
+if true {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('if with boolean typed variable condition passes', () => {
+    const ast = parse(`
+let flag: boolean = true
+if flag {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return with no value inside function', () => {
+    const ast = parse(`
+function test() {
+  return
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple return errors
+  // ============================================================================
+
+  test('multiple returns at top level', () => {
+    const ast = parse(`
+return "first"
+return "second"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe('return outside of function');
+    expect(errors[1].message).toBe('return outside of function');
+  });
+
+  // ============================================================================
+  // Combined with other errors
+  // ============================================================================
+
+  test('return outside function with undefined variable', () => {
+    const ast = parse(`
+return undefinedVar
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe('return outside of function');
+    expect(errors[1].message).toBe("'undefinedVar' is not defined");
+  });
+
+  // ============================================================================
+  // While loop semantic checks
+  // ============================================================================
+
+  test('while loop with undefined condition variable', () => {
+    const ast = parse(`
+while undefinedVar {
+  let x = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedVar' is not defined");
+  });
+
+  test('while loop with valid condition', () => {
+    const ast = parse(`
+let keepGoing = true
+while keepGoing {
+  keepGoing = false
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('while loop body variables not visible outside', () => {
+    const ast = parse(`
+while true {
+  let innerVar = 1
+}
+let x = innerVar
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'innerVar' is not defined");
+  });
+
+  test('while loop can access outer variables', () => {
+    const ast = parse(`
+let outerVar = true
+while outerVar {
+  outerVar = false
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('nested while loops have proper scoping', () => {
+    const ast = parse(`
+let outer = true
+while outer {
+  let middle = true
+  while middle {
+    let inner = true
+    middle = false
+  }
+  outer = false
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return inside while loop in function is valid', () => {
+    const ast = parse(`
+function test(): boolean {
+  while true {
+    return true
+  }
+  return false
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('return inside while loop at top level is invalid', () => {
+    const ast = parse(`
+while true {
+  return true
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('return outside of function');
+  });
+
+  test('while with non-boolean literal condition errors', () => {
+    const ast = parse(`
+while "test" {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('while condition must be boolean, got text');
+  });
+
+  test('while with non-boolean typed variable condition errors', () => {
+    const ast = parse(`
+const x: text = "test"
+while x {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('while condition must be boolean, got text');
+  });
+
+  test('while with number literal condition errors', () => {
+    const ast = parse(`
+while 5 {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('while condition must be boolean, got number');
+  });
+
+  test('while with inferred text variable condition errors', () => {
+    // With type inference, const x = "test" has inferred type 'text'
+    // Using text as while condition should error
+    const ast = parse(`
+const x = "test"
+while x {
+  let y = 1
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('while condition must be boolean, got text');
+  });
+});

package/src/semantic/test/destructuring.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Validation - Destructuring Declarations', () => {
+  // ============================================================================
+  // Valid cases
+  // ============================================================================
+
+  test('valid const destructuring from do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {name: text, age: number} = do "get info" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid let destructuring from do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let {valid: boolean, reason: text} = do "validate" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid destructuring with array types', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {items: text[], counts: number[]} = do "get lists" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Duplicate field names within destructuring pattern
+  // ============================================================================
+
+  test('duplicate field name in destructuring pattern', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {name: text, name: number} = do "get info" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain("Duplicate field 'name'");
+  });
+
+  test('multiple duplicate field names in pattern', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {x: number, y: number, x: text, y: text} = do "get" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toContain("Duplicate field 'x'");
+    expect(errors[1].message).toContain("Duplicate field 'y'");
+  });
+
+  // ============================================================================
+  // Destructuring creates variables that can conflict
+  // ============================================================================
+
+  test('destructuring field conflicts with existing variable', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let name = "existing"
+const {name: text, age: number} = do "get info" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'name' is already declared");
+  });
+
+  test('destructuring field conflicts with function', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+function greet() { return "hi" }
+const {greet: text} = do "get" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'greet' is already declared");
+  });
+
+  test('two destructurings with conflicting fields', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {name: text} = do "get name" m
+const {name: number} = do "get another" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'name' is already declared");
+  });
+
+  // ============================================================================
+  // Invalid initializer (must be AI expression)
+  // ============================================================================
+
+  test('destructuring from string literal is invalid', () => {
+    const ast = parse(`
+const {name: text} = "not an AI call"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Destructuring assignment requires a do or vibe expression');
+  });
+
+  test('destructuring from number is invalid', () => {
+    const ast = parse(`
+const {value: number} = 42
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Destructuring assignment requires a do or vibe expression');
+  });
+
+  test('destructuring from variable is invalid', () => {
+    const ast = parse(`
+let data = "test"
+const {name: text} = data
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Destructuring assignment requires a do or vibe expression');
+  });
+
+  // ============================================================================
+  // Shadowing in nested scopes (valid)
+  // ============================================================================
+
+  test('destructuring in block can shadow outer variable', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let name = "outer"
+if true {
+  const {name: text} = do "get" m
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('destructuring in function can shadow outer variable', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let name = "outer"
+function test() {
+  const {name: text} = do "get" m
+  return name
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Using destructured variables
+  // ============================================================================
+
+  test('can use destructured variables', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+const {name: text, age: number} = do "get" m
+let greeting = name
+let years = age
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('cannot use destructured variable before declaration', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let x = name
+const {name: text} = do "get" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain("'name' is not defined");
+  });
+});

package/src/semantic/test/duplicate-declarations.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Duplicate Declarations', () => {
+  // ============================================================================
+  // Basic duplicate declarations
+  // ============================================================================
+
+  test('duplicate let declaration', () => {
+    const ast = parse(`
+let x = "hello"
+let x = "world"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'x' is already declared");
+  });
+
+  test('duplicate const declaration', () => {
+    const ast = parse(`
+const x = "hello"
+const x = "world"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'x' is already declared");
+  });
+
+  test('let and const with same name', () => {
+    const ast = parse(`
+let x = "hello"
+const x = "world"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'x' is already declared");
+  });
+
+  test('duplicate function declaration', () => {
+    const ast = parse(`
+function greet(name: text): text {
+  return name
+}
+function greet(x: text): text {
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'greet' is already declared");
+  });
+
+  test('duplicate model declaration', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+model myModel = { name: "test2", apiKey: "key2", url: "http://test2" }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'myModel' is already declared");
+  });
+
+  // ============================================================================
+  // Cross-type duplicates
+  // ============================================================================
+
+  test('variable and function with same name', () => {
+    const ast = parse(`
+let greet = "hello"
+function greet(name: text): text {
+  return name
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'greet' is already declared");
+  });
+
+  test('variable and model with same name', () => {
+    const ast = parse(`
+let myModel = "test"
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'myModel' is already declared");
+  });
+
+  test('function and model with same name', () => {
+    const ast = parse(`
+function myModel() {
+  return "test"
+}
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'myModel' is already declared");
+  });
+
+  // ============================================================================
+  // Shadowing in nested scopes (valid)
+  // ============================================================================
+
+  test('shadowing in block scope is valid', () => {
+    const ast = parse(`
+let x = "outer"
+if true {
+  let x = "inner"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('shadowing in function scope is valid', () => {
+    const ast = parse(`
+let x = "outer"
+function test() {
+  let x = "inner"
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('function parameter shadows outer variable is valid', () => {
+    const ast = parse(`
+let name = "outer"
+function greet(name: text): text {
+  return name
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple duplicates
+  // ============================================================================
+
+  test('multiple duplicate declarations', () => {
+    const ast = parse(`
+let x = "first"
+let x = "second"
+let x = "third"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("'x' is already declared");
+    expect(errors[1].message).toBe("'x' is already declared");
+  });
+
+  test('different duplicate declarations', () => {
+    const ast = parse(`
+let x = "first"
+let y = "first"
+let x = "second"
+let y = "second"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("'x' is already declared");
+    expect(errors[1].message).toBe("'y' is already declared");
+  });
+});