@vibe-lang/runtime 0.2.5

package/src/semantic/test/export-validation.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Export Validation', () => {
+  // ============================================================================
+  // Export let is not allowed
+  // ============================================================================
+
+  test('cannot export let variable', () => {
+    const ast = parse(`
+export let x = "hello"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot export mutable variable 'x'. Only constants can be exported.");
+  });
+
+  test('cannot export let with type annotation', () => {
+    const ast = parse(`
+export let count: number = 42
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot export mutable variable 'count'. Only constants can be exported.");
+  });
+
+  // ============================================================================
+  // Valid exports
+  // ============================================================================
+
+  test('can export const variable', () => {
+    const ast = parse(`
+export const X = "hello"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('can export const with type annotation', () => {
+    const ast = parse(`
+export const COUNT: number = 42
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('can export function', () => {
+    const ast = parse(`
+export function greet(name: text): text {
+  return "Hello " + name
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('can export model', () => {
+    const ast = parse(`
+export model myModel = {
+  name: "gpt-4",
+  provider: "openai",
+  apiKey: "test",
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple exports
+  // ============================================================================
+
+  test('multiple export let errors reported separately', () => {
+    const ast = parse(`
+export let a = 1
+export let b = 2
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("Cannot export mutable variable 'a'. Only constants can be exported.");
+    expect(errors[1].message).toBe("Cannot export mutable variable 'b'. Only constants can be exported.");
+  });
+
+  test('mixed valid and invalid exports', () => {
+    const ast = parse(`
+export const VALID = "ok"
+export let invalid = "not ok"
+export function alsoValid(): text {
+  return "ok"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot export mutable variable 'invalid'. Only constants can be exported.");
+  });
+
+  // ============================================================================
+  // Non-exported let is still allowed
+  // ============================================================================
+
+  test('non-exported let is allowed', () => {
+    const ast = parse(`
+let x = "hello"
+export const Y = x
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});

package/src/semantic/test/fixtures/math.ts

@@ -0,0 +1,31 @@
+/**
+ * Test fixture for TS type checking tests
+ */
+
+// Function declaration
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+// Arrow function
+export const multiply = (a: number, b: number): number => a * b;
+
+// Function with optional parameter
+export function greet(name: string, greeting?: string): string {
+  return `${greeting ?? 'Hello'}, ${name}!`;
+}
+
+// Function with object parameter
+export function processData(data: Record<string, unknown>): string {
+  return JSON.stringify(data);
+}
+
+// Function with array parameter
+export function sumArray(nums: number[]): number {
+  return nums.reduce((a, b) => a + b, 0);
+}
+
+// Function with default parameter
+export function repeat(str: string, times: number = 1): string {
+  return str.repeat(times);
+}

package/src/semantic/test/imports.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../analyzer';
+
+function analyze(source: string) {
+  const ast = parse(source);
+  const analyzer = new SemanticAnalyzer();
+  return analyzer.analyze(ast, source);
+}
+
+describe('Semantic Analysis - Import Declarations', () => {
+  test('valid import declaration', () => {
+    const errors = analyze(`
+      import { add } from "./math.ts"
+      let result = add("1", "2")
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('multiple imports from same file', () => {
+    const errors = analyze(`
+      import { add, subtract } from "./math.ts"
+      let sum = add("1", "2")
+      let diff = subtract("5", "3")
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('imports from different files', () => {
+    const errors = analyze(`
+      import { add } from "./math.ts"
+      import { greet } from "./greet.vibe"
+      let sum = add("1", "2")
+      let greeting = greet("Alice")
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('error: duplicate import name from different sources', () => {
+    const errors = analyze(`
+      import { helper } from "./a.ts"
+      import { helper } from "./b.ts"
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/already imported/);
+  });
+
+  test('error: import conflicts with local function', () => {
+    const errors = analyze(`
+      function add(a: text, b: text): text {
+        return a
+      }
+      import { add } from "./math.ts"
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/conflicts with existing function/);
+  });
+
+  test('error: import conflicts with local variable', () => {
+    const errors = analyze(`
+      let counter = "0"
+      import { counter } from "./state.ts"
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/conflicts with existing variable/);
+  });
+
+  test('error: import conflicts with model', () => {
+    const errors = analyze(`
+      model gpt = { name: "gpt-4", apiKey: "key", url: "url" }
+      import { gpt } from "./models.ts"
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/conflicts with existing model/);
+  });
+
+  test('error: cannot reassign import', () => {
+    const errors = analyze(`
+      import { counter } from "./state.ts"
+      counter = "new value"
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/Cannot reassign imported/);
+  });
+});
+
+describe('Semantic Analysis - Export Declarations', () => {
+  test('valid export function', () => {
+    const errors = analyze(`
+      model gpt = { name: "gpt-4", apiKey: "key", url: "url" }
+      export function greet(name: text): text {
+        return vibe "Hello {name}" gpt default
+      }
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('valid export const', () => {
+    const errors = analyze(`
+      export const API_KEY = "secret"
+      export const COUNT = 42
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('valid export model', () => {
+    const errors = analyze(`
+      export model gpt = { name: "gpt-4", apiKey: "key", url: "url" }
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('error: duplicate export names', () => {
+    const errors = analyze(`
+      export function foo() { return "a" }
+      export function foo() { return "b" }
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/already declared/);
+  });
+});
+
+describe('Semantic Analysis - TsBlock', () => {
+  test('valid ts block with defined parameters', () => {
+    const errors = analyze(`
+      let a = "5"
+      let b = "3"
+      let sum = ts(a, b) { return a + b }
+    `);
+    expect(errors).toHaveLength(0);
+  });
+
+  test('error: ts block with undefined parameter', () => {
+    const errors = analyze(`
+      let a = "5"
+      let sum = ts(a, b) { return a + b }
+    `);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toMatch(/'b' is not defined/);
+  });
+
+  test('error: ts block with multiple undefined parameters', () => {
+    const errors = analyze(`
+      let sum = ts(x, y, z) { return x + y + z }
+    `);
+    expect(errors).toHaveLength(3);
+  });
+});

package/src/semantic/test/json-type.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - JSON Type Strictness', () => {
+  // ============================================================================
+  // json type cannot be array
+  // ============================================================================
+
+  test('json type rejects array literal', () => {
+    const ast = parse(`let x: json = [1, 2, 3]`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('json type expects an object, not an array. Use json[] for arrays.');
+  });
+
+  test('json type rejects array of objects literal', () => {
+    const ast = parse(`let x: json = [{ a: 1 }, { b: 2 }]`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('json type expects an object, not an array. Use json[] for arrays.');
+  });
+
+  test('json type rejects empty array literal', () => {
+    const ast = parse(`let x: json = []`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('json type expects an object, not an array. Use json[] for arrays.');
+  });
+
+  // ============================================================================
+  // json type accepts objects
+  // ============================================================================
+
+  test('json type accepts object literal', () => {
+    const ast = parse(`let x: json = { name: "Alice", age: 30 }`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('json type accepts empty object literal', () => {
+    const ast = parse(`let x: json = {}`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('json type accepts nested object literal', () => {
+    const ast = parse(`let x: json = { user: { name: "Bob", items: [1, 2, 3] } }`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // json[] type for arrays
+  // ============================================================================
+
+  test('json[] accepts array of objects', () => {
+    const ast = parse(`let x: json[] = [{ a: 1 }, { b: 2 }]`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('json[] accepts empty array', () => {
+    const ast = parse(`let x: json[] = []`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});

package/src/semantic/test/literals.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../analyzer';
+
+describe('Semantic Analyzer - Object and Array Literals', () => {
+  const analyzer = new SemanticAnalyzer();
+
+  function getErrors(code: string): string[] {
+    const ast = parse(code);
+    const errors = analyzer.analyze(ast, code);
+    return errors.map((e) => e.message);
+  }
+
+  // ============================================================================
+  // Valid cases
+  // ============================================================================
+
+  test('object literal with string values is valid', () => {
+    const errors = getErrors('let x = {name: "test"}');
+    expect(errors).toEqual([]);
+  });
+
+  test('array literal with string values is valid', () => {
+    const errors = getErrors('let x = ["a", "b", "c"]');
+    expect(errors).toEqual([]);
+  });
+
+  test('object literal with defined variable reference is valid', () => {
+    const errors = getErrors(`
+      let name = "alice"
+      let x = {user: name}
+    `);
+    expect(errors).toEqual([]);
+  });
+
+  test('array literal with defined variable reference is valid', () => {
+    const errors = getErrors(`
+      let item = "first"
+      let x = [item, "second"]
+    `);
+    expect(errors).toEqual([]);
+  });
+
+  test('nested object literal is valid', () => {
+    const errors = getErrors('let x = {outer: {inner: "value"}}');
+    expect(errors).toEqual([]);
+  });
+
+  test('nested array literal is valid', () => {
+    const errors = getErrors('let x = [["a"], ["b"]]');
+    expect(errors).toEqual([]);
+  });
+
+  test('array of objects is valid', () => {
+    const errors = getErrors('let x = [{name: "a"}, {name: "b"}]');
+    expect(errors).toEqual([]);
+  });
+
+  test('object with array property is valid', () => {
+    const errors = getErrors('let x = {items: ["a", "b"]}');
+    expect(errors).toEqual([]);
+  });
+
+  // ============================================================================
+  // Undefined variable errors
+  // ============================================================================
+
+  test('undefined variable in object literal value', () => {
+    const errors = getErrors('let x = {name: undefined_var}');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('undefined variable in array literal element', () => {
+    const errors = getErrors('let x = ["valid", undefined_var]');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('undefined variable in nested object', () => {
+    const errors = getErrors('let x = {outer: {inner: undefined_var}}');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('undefined variable in nested array', () => {
+    const errors = getErrors('let x = [["valid"], [undefined_var]]');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('undefined variable in object inside array', () => {
+    const errors = getErrors('let x = [{name: undefined_var}]');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('undefined variable in array inside object', () => {
+    const errors = getErrors('let x = {items: [undefined_var]}');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+
+  test('multiple undefined variables reported', () => {
+    const errors = getErrors('let x = {a: undefined1, b: undefined2}');
+    expect(errors).toContain("'undefined1' is not defined");
+    expect(errors).toContain("'undefined2' is not defined");
+  });
+
+  // ============================================================================
+  // With type annotations
+  // ============================================================================
+
+  test('json type with object literal is valid', () => {
+    const errors = getErrors('let x: json = {name: "test"}');
+    expect(errors).toEqual([]);
+  });
+
+  test('json type with array literal is error (use json[] for arrays)', () => {
+    const errors = getErrors('let x: json = ["a", "b"]');
+    expect(errors).toContain('json type expects an object, not an array. Use json[] for arrays.');
+  });
+
+  test('json[] type with array literal is valid', () => {
+    const errors = getErrors('let x: json[] = [{ a: 1 }, { b: 2 }]');
+    expect(errors).toEqual([]);
+  });
+
+  test('json type with undefined variable in literal still errors', () => {
+    const errors = getErrors('let x: json = {name: undefined_var}');
+    expect(errors).toContain("'undefined_var' is not defined");
+  });
+});

package/src/semantic/test/model-validation.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Model Validation', () => {
+  // ============================================================================
+  // Model reassignment (should be blocked)
+  // ============================================================================
+
+  test('cannot reassign model variable', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test",
+  url: "https://api.openai.com"
+}
+myModel = "something"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot reassign model 'myModel'");
+  });
+
+  // ============================================================================
+  // Required fields validation
+  // ============================================================================
+
+  test('model with all required fields is valid', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test",
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('model missing name field', () => {
+    const ast = parse(`
+model myModel = {
+  apiKey: "sk-test",
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Model 'myModel' is missing required field 'name'");
+  });
+
+  test('model missing apiKey field', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Model 'myModel' is missing required field 'apiKey'");
+  });
+
+  test('model missing url field', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Model 'myModel' is missing required field 'url'");
+  });
+
+  test('model missing all fields', () => {
+    const ast = parse(`
+model myModel = {}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(3);
+    expect(errors.map(e => e.message)).toContain("Model 'myModel' is missing required field 'name'");
+    expect(errors.map(e => e.message)).toContain("Model 'myModel' is missing required field 'apiKey'");
+    expect(errors.map(e => e.message)).toContain("Model 'myModel' is missing required field 'url'");
+  });
+
+  // ============================================================================
+  // Unknown fields validation
+  // ============================================================================
+
+  test('model with unknown field', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test",
+  url: "https://api.openai.com",
+  streaming: true
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Model 'myModel' has unknown field 'streaming'");
+  });
+
+  test('model with multiple unknown fields', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test",
+  url: "https://api.openai.com",
+  streaming: true,
+  temperature: "0.7"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors.map(e => e.message)).toContain("Model 'myModel' has unknown field 'streaming'");
+    expect(errors.map(e => e.message)).toContain("Model 'myModel' has unknown field 'temperature'");
+  });
+
+  // ============================================================================
+  // Field expression validation
+  // ============================================================================
+
+  test('model field can reference defined variable', () => {
+    const ast = parse(`
+let myKey = "sk-test"
+model myModel = {
+  name: "gpt-4",
+  apiKey: myKey,
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('model field referencing undefined variable', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: undefinedKey,
+  url: "https://api.openai.com"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedKey' is not defined");
+  });
+
+  // ============================================================================
+  // Model type annotation must be const
+  // ============================================================================
+
+  test('let with model type is rejected', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let m: model = myModel
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Variables with type 'model' must be declared with 'const', not 'let'");
+  });
+
+  test('const with model type is allowed', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+const m: model = myModel
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('function parameter with model type is allowed', () => {
+    const ast = parse(`function process(m: model): text { return "done" }`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});