@vibe-lang/runtime 0.2.5

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

@@ -0,0 +1,563 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../analyzer';
+import { extractFunctionSignature, clearSignatureCache } from '../ts-signatures';
+import { checkTsBlockTypes, inferTsBlockReturnType } from '../ts-block-checker';
+import { join } from 'path';
+
+// Test fixtures directory
+const fixturesDir = join(__dirname, 'fixtures');
+
+describe('TS Signature Extraction', () => {
+  beforeEach(() => {
+    clearSignatureCache();
+  });
+
+  test('extracts function declaration signature', () => {
+    const sig = extractFunctionSignature(
+      join(fixturesDir, 'math.ts'),
+      'add'
+    );
+    expect(sig).toBeDefined();
+    expect(sig!.name).toBe('add');
+    expect(sig!.params).toHaveLength(2);
+    expect(sig!.params[0]).toEqual({ name: 'a', tsType: 'number', optional: false });
+    expect(sig!.params[1]).toEqual({ name: 'b', tsType: 'number', optional: false });
+    expect(sig!.returnType).toBe('number');
+  });
+
+  test('extracts arrow function signature', () => {
+    const sig = extractFunctionSignature(
+      join(fixturesDir, 'math.ts'),
+      'multiply'
+    );
+    expect(sig).toBeDefined();
+    expect(sig!.name).toBe('multiply');
+    expect(sig!.params).toHaveLength(2);
+    expect(sig!.params[0].tsType).toBe('number');
+    expect(sig!.params[1].tsType).toBe('number');
+    expect(sig!.returnType).toBe('number');
+  });
+
+  test('extracts function with optional parameter', () => {
+    const sig = extractFunctionSignature(
+      join(fixturesDir, 'math.ts'),
+      'greet'
+    );
+    expect(sig).toBeDefined();
+    expect(sig!.params).toHaveLength(2);
+    expect(sig!.params[0]).toEqual({ name: 'name', tsType: 'string', optional: false });
+    expect(sig!.params[1].optional).toBe(true);
+  });
+
+  test('extracts function with object parameter', () => {
+    const sig = extractFunctionSignature(
+      join(fixturesDir, 'math.ts'),
+      'processData'
+    );
+    expect(sig).toBeDefined();
+    expect(sig!.params).toHaveLength(1);
+    // The type should be object-like
+    expect(sig!.params[0].name).toBe('data');
+  });
+
+  test('returns undefined for non-existent function', () => {
+    const sig = extractFunctionSignature(
+      join(fixturesDir, 'math.ts'),
+      'nonExistent'
+    );
+    expect(sig).toBeUndefined();
+  });
+
+  test('caches extracted signatures', () => {
+    const sig1 = extractFunctionSignature(join(fixturesDir, 'math.ts'), 'add');
+    const sig2 = extractFunctionSignature(join(fixturesDir, 'math.ts'), 'add');
+    expect(sig1).toBe(sig2); // Same object reference (cached)
+  });
+});
+
+describe('TS Block Return Type Inference', () => {
+  test('infers text from string return', () => {
+    const type = inferTsBlockReturnType([], 'return "hello"');
+    expect(type).toBe('text');
+  });
+
+  test('infers number from number return', () => {
+    const type = inferTsBlockReturnType([], 'return 42');
+    expect(type).toBe('number');
+  });
+
+  test('infers boolean from boolean return', () => {
+    const type = inferTsBlockReturnType([], 'return true');
+    expect(type).toBe('boolean');
+  });
+
+  test('infers json from object return', () => {
+    const type = inferTsBlockReturnType([], 'return { key: "value" }');
+    expect(type).toBe('json');
+  });
+
+  test('infers json[] from array return', () => {
+    const type = inferTsBlockReturnType([], 'return [1, 2, 3]');
+    // Arrays of numbers become number[]
+    expect(type).toBe('number[]');
+  });
+
+  test('infers type from parameter operation', () => {
+    const type = inferTsBlockReturnType(
+      [{ name: 'x', vibeType: 'number' }],
+      'return x * 2'
+    );
+    expect(type).toBe('number');
+  });
+
+  test('infers text from string concatenation', () => {
+    const type = inferTsBlockReturnType(
+      [{ name: 's', vibeType: 'text' }],
+      'return s + "!"'
+    );
+    expect(type).toBe('text');
+  });
+
+  test('infers null from void return', () => {
+    // Note: 'return undefined' and 'return null' are expressions that TS types as 'any'
+    // Only bare 'return' (void) maps to null
+    const type = inferTsBlockReturnType([], 'return');
+    expect(type).toBe('null');
+  });
+});
+
+describe('TS Block Type Checking', () => {
+  test('no errors for valid type usage', () => {
+    const errors = checkTsBlockTypes(
+      [{ name: 'x', vibeType: 'number' }],
+      'return x * 2',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('error for invalid operation on string', () => {
+    const errors = checkTsBlockTypes(
+      [{ name: 'x', vibeType: 'text' }],
+      'return x * 2',
+      { line: 1, column: 1 }
+    );
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].message).toContain('TypeScript error');
+  });
+
+  test('no errors when no typed parameters', () => {
+    // If no parameters have types, we skip checking
+    const errors = checkTsBlockTypes(
+      [],
+      'return undefinedVar * 2',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('no errors for external function calls', () => {
+    // External functions like fetchData() should not error
+    const errors = checkTsBlockTypes(
+      [{ name: 'x', vibeType: 'number' }],
+      'return externalFunction(x)',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('error includes location info', () => {
+    const errors = checkTsBlockTypes(
+      [{ name: 's', vibeType: 'text' }],
+      'return s * 2',
+      { line: 10, column: 5 }
+    );
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].location.line).toBeGreaterThanOrEqual(10);
+  });
+
+  test('handles multiple parameters', () => {
+    const errors = checkTsBlockTypes(
+      [
+        { name: 'a', vibeType: 'number' },
+        { name: 'b', vibeType: 'text' },
+      ],
+      'return a + b.length',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('handles json type as Record', () => {
+    const errors = checkTsBlockTypes(
+      [{ name: 'data', vibeType: 'json' }],
+      'return data.key',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('prompt type maps to string in ts blocks', () => {
+    // prompt should be treated as string, allowing string operations
+    const errors = checkTsBlockTypes(
+      [{ name: 'p', vibeType: 'prompt' }],
+      'return p.toUpperCase()',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('prompt type allows string concatenation', () => {
+    const errors = checkTsBlockTypes(
+      [{ name: 'p', vibeType: 'prompt' }],
+      'return "Hello: " + p',
+      { line: 1, column: 1 }
+    );
+    expect(errors).toHaveLength(0);
+  });
+
+  test('prompt type disallows number operations', () => {
+    // prompt maps to string, so number operations should fail
+    const errors = checkTsBlockTypes(
+      [{ name: 'p', vibeType: 'prompt' }],
+      'return p * 2',
+      { line: 1, column: 1 }
+    );
+    expect(errors.length).toBeGreaterThan(0);
+  });
+});
+
+describe('Semantic Analyzer - TS Import Type Checking', () => {
+  const analyzer = new SemanticAnalyzer();
+
+  function getErrors(code: string, basePath?: string): string[] {
+    const ast = parse(code);
+    const errors = analyzer.analyze(ast, code, basePath ?? fixturesDir + '/main.vibe');
+    return errors.map((e) => e.message);
+  }
+
+  test('TS function call with correct types passes', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x: number = 5
+let result = add(x, 10)
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('TS function call with wrong arg type errors', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x: text = "hi"
+let result = add(x, 5)
+`);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('expected number') && e.includes('got text'))).toBe(true);
+  });
+
+  test('TS function call with too few arguments errors', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let result = add(5)
+`);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('requires 2 arguments'))).toBe(true);
+  });
+
+  test('TS function call with too many arguments errors', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let result = add(1, 2, 3)
+`);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('accepts at most'))).toBe(true);
+  });
+
+  test('TS function with optional param - missing optional is ok', () => {
+    const errors = getErrors(`
+import { greet } from "./math.ts"
+let result = greet("Alice")
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('json type is compatible with object params', () => {
+    const errors = getErrors(`
+import { processData } from "./math.ts"
+let data: json = "{}"
+processData(data)
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('text type incompatible with number param', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let s: text = "hello"
+add(s, s)
+`);
+    expect(errors.length).toBe(2); // Both args wrong
+  });
+
+  test('number literal is compatible with number param', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+add(1, 2)
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('boolean type incompatible with string param', () => {
+    const errors = getErrors(`
+import { greet } from "./math.ts"
+let b: boolean = true
+greet(b)
+`);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('expected string') && e.includes('got boolean'))).toBe(true);
+  });
+
+  test('prompt type is compatible with string param in TS function', () => {
+    const errors = getErrors(`
+import { greet } from "./math.ts"
+let p: prompt = "Alice"
+greet(p)
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('prompt type works with TS function expecting string', () => {
+    const errors = getErrors(`
+import { repeat } from "./math.ts"
+let p: prompt = "hello"
+let result = repeat(p, 3)
+`);
+    expect(errors).toEqual([]);
+  });
+});
+
+describe('Semantic Analyzer - ts() Block Type Checking', () => {
+  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);
+  }
+
+  test('ts block with valid type usage passes', () => {
+    const errors = getErrors(`
+let x: number = 5
+let result = ts(x) { return x * 2 }
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('ts block with invalid type usage errors', () => {
+    const errors = getErrors(`
+let x: text = "hello"
+let result = ts(x) { return x * 2 }
+`);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('TypeScript error'))).toBe(true);
+  });
+
+  test('ts block with untyped parameter skips checking', () => {
+    // If parameter has no type, we can't check it
+    const errors = getErrors(`
+let x = someFn()
+let result = ts(x) { return x * 2 }
+`);
+    // Should only error about someFn not being defined, not TS type errors
+    expect(errors.some(e => e.includes("'someFn' is not defined"))).toBe(true);
+  });
+
+  test('ts block with undefined parameter errors', () => {
+    const errors = getErrors(`
+let result = ts(undefinedVar) { return undefinedVar }
+`);
+    expect(errors.some(e => e.includes("'undefinedVar' is not defined"))).toBe(true);
+  });
+
+  test('ts block with no parameters skips type checking', () => {
+    const errors = getErrors(`
+let result = ts() { return fetchData() }
+`);
+    // Should not error - external calls are allowed
+    expect(errors).toEqual([]);
+  });
+
+  test('ts block with json parameter works', () => {
+    const errors = getErrors(`
+let data: json = "{}"
+let result = ts(data) { return data.key }
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('ts block with multiple typed parameters', () => {
+    const errors = getErrors(`
+let a: number = 1
+let b: text = "hi"
+let result = ts(a, b) { return a + b.length }
+`);
+    expect(errors).toEqual([]);
+  });
+});
+
+describe('Return Type Inference - ts() Blocks', () => {
+  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);
+  }
+
+  test('infers text type from ts block returning string', () => {
+    const errors = getErrors(`
+let x = ts() { return "hello" }
+let y: number = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign text to number');
+  });
+
+  test('infers number type from ts block returning number', () => {
+    const errors = getErrors(`
+let x = ts() { return 42 }
+let y: text = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+
+  test('infers boolean type from ts block returning boolean', () => {
+    const errors = getErrors(`
+let x = ts() { return true }
+let y: text = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign boolean to text');
+  });
+
+  test('infers array type from ts block returning array', () => {
+    const errors = getErrors(`
+let x: text = ts() { return [] }
+`);
+    expect(errors.length).toBe(1);
+    // Arrays map to json[] or similar
+    expect(errors[0]).toContain('cannot assign');
+  });
+
+  test('infers json type from ts block returning object', () => {
+    const errors = getErrors(`
+let x = ts() { return { key: "value" } }
+let y: number = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign json to number');
+  });
+
+  test('correct inference allows compatible assignment', () => {
+    const errors = getErrors(`
+let x = ts() { return "hello" }
+let y: text = x
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('infers type through parameter usage', () => {
+    const errors = getErrors(`
+let a: number = 5
+let x = ts(a) { return a * 2 }
+let y: text = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+
+  test('type mismatch with explicit annotation on ts block variable', () => {
+    const errors = getErrors(`
+let x: text = ts() { return 42 }
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+
+  test('type mismatch with array return to text', () => {
+    const errors = getErrors(`
+let x: text = ts() { return [1, 2, 3] }
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign');
+  });
+});
+
+describe('Return Type Inference - Imported TS Functions', () => {
+  const analyzer = new SemanticAnalyzer();
+
+  function getErrors(code: string): string[] {
+    const ast = parse(code);
+    const errors = analyzer.analyze(ast, code, fixturesDir + '/main.vibe');
+    return errors.map((e) => e.message);
+  }
+
+  test('infers number type from TS function returning number', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x = add(1, 2)
+let y: text = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+
+  test('type mismatch when assigning TS function result to wrong type', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x: text = add(1, 2)
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+
+  test('correct type assignment from TS function', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x: number = add(1, 2)
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('inferred type allows correct usage', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let x = add(1, 2)
+let y: number = x
+`);
+    expect(errors).toEqual([]);
+  });
+
+  test('infers string type from TS function returning string', () => {
+    const errors = getErrors(`
+import { greet } from "./math.ts"
+let x = greet("Alice")
+let y: number = x
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign text to number');
+  });
+
+  test('chained inference through TS function and variable', () => {
+    const errors = getErrors(`
+import { add } from "./math.ts"
+let a = add(1, 2)
+let b = a
+let c: text = b
+`);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('cannot assign number to text');
+  });
+});

package/src/semantic/test/type-constraints.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 - Type Constraints', () => {
+  // ============================================================================
+  // Do expression model argument must be a model type
+  // ============================================================================
+
+  test('vibe expression with variable as model argument', () => {
+    const ast = parse(`
+let notAModel = "test"
+let x: text = vibe "prompt" notAModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Expected model, got variable 'notAModel'");
+  });
+
+  test('vibe expression with constant as model argument', () => {
+    const ast = parse(`
+const notAModel = "test"
+let x: text = vibe "prompt" notAModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Expected model, got constant 'notAModel'");
+  });
+
+  test('vibe expression with function as model argument', () => {
+    const ast = parse(`
+function notAModel() {
+  return "test"
+}
+let x: text = vibe "prompt" notAModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Expected model, got function 'notAModel'");
+  });
+
+  test('vibe expression with parameter as model argument', () => {
+    const ast = parse(`
+model realModel = { name: "test", apiKey: "key", url: "http://test" }
+function test(notAModel: text): text {
+  let x: text = vibe "prompt" notAModel default
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Expected model, got parameter 'notAModel'");
+  });
+
+  // ============================================================================
+  // Valid model usage
+  // ============================================================================
+
+  test('vibe expression with valid model', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let x: text = vibe "prompt" myModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('vibe expression with model from outer scope', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+function test() {
+  let x: text = vibe "prompt" myModel default
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple type errors
+  // ============================================================================
+
+  test('multiple vibe expressions with wrong model types', () => {
+    const ast = parse(`
+let notAModel = "test"
+let x: text = vibe "prompt1" notAModel default
+let y: text = vibe "prompt2" notAModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("Expected model, got variable 'notAModel'");
+    expect(errors[1].message).toBe("Expected model, got variable 'notAModel'");
+  });
+
+  // ============================================================================
+  // Combined errors
+  // ============================================================================
+
+  test('undefined model and wrong type model', () => {
+    const ast = parse(`
+let notAModel = "test"
+let x: text = vibe "prompt1" undefinedModel default
+let y: text = vibe "prompt2" notAModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("'undefinedModel' is not defined");
+    expect(errors[1].message).toBe("Expected model, got variable 'notAModel'");
+  });
+});