@vibe-lang/runtime 0.2.5

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

@@ -0,0 +1,343 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../analyzer';
+
+describe('Semantic Analyzer - Prompt Parameter Validation', () => {
+  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);
+  }
+
+  const modelDecl = 'model m = { name: "test", apiKey: "key", url: "http://test" }';
+
+  // ============================================================================
+  // Valid prompt parameters - String literals
+  // ============================================================================
+
+  describe('string literals as prompts', () => {
+    test('vibe with string literal prompt is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe "What is 2+2?" m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with question prompt is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe "What is your name?" m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with string literal prompt is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe "Generate a hello function" m default
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // Valid prompt parameters - Variables with prompt type
+  // ============================================================================
+
+  describe('prompt typed variables as prompts', () => {
+    test('vibe with prompt typed variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let question: prompt = "What is 2+2?"
+        let x: text = vibe question m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with const prompt variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        const userPrompt: prompt = "What is your name?"
+        let x: text = vibe userPrompt m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with prompt typed variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let instruction: prompt = "Generate a hello function"
+        let x: text = vibe instruction m default
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // Valid prompt parameters - Variables with text type
+  // ============================================================================
+
+  describe('text typed variables as prompts', () => {
+    test('vibe with text typed variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let question: text = "What is 2+2?"
+        let x: text = vibe question m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with const text variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        const userInput: text = "What is your name?"
+        let x: text = vibe userInput m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with text typed variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let instruction: text = "Generate code"
+        let x: text = vibe instruction m default
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // Valid prompt parameters - Variables without type annotation (implicitly text)
+  // ============================================================================
+
+  describe('untyped variables as prompts', () => {
+    test('vibe with untyped variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let question = "What is 2+2?"
+        let x: text = vibe question m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with const untyped variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        const userInput = "What is your name?"
+        let x: text = vibe userInput m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with untyped variable is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let instruction = "Generate code"
+        let x: text = vibe instruction m default
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // Invalid prompt parameters - JSON typed variables
+  // ============================================================================
+
+  describe('json typed variables as prompts (invalid)', () => {
+    test('vibe with json typed variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let data: json = "{\\"key\\": \\"value\\"}"
+        let x: text = vibe data m default
+      `);
+      expect(errors).toContain("Cannot use json typed variable 'data' as prompt");
+    });
+
+    test('vibe with const json variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        const config: json = "[]"
+        let x: text = vibe config m default
+      `);
+      expect(errors).toContain("Cannot use json typed variable 'config' as prompt");
+    });
+
+    test('vibe with json typed variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let schema: json = "{}"
+        let x: text = vibe schema m default
+      `);
+      expect(errors).toContain("Cannot use json typed variable 'schema' as prompt");
+    });
+  });
+
+  // ============================================================================
+  // Invalid prompt parameters - Model references
+  // ============================================================================
+
+  describe('model references as prompts (invalid)', () => {
+    test('vibe with model as prompt errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe m m default
+      `);
+      expect(errors).toContain("Cannot use model 'm' as prompt");
+    });
+
+    test('vibe with model as both prompt and model errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe m m default
+      `);
+      expect(errors).toContain("Cannot use model 'm' as prompt");
+    });
+  });
+
+  // ============================================================================
+  // Invalid prompt parameters - Function references
+  // ============================================================================
+
+  describe('function references as prompts (invalid)', () => {
+    test('vibe with function as prompt errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function myFunc() {
+          return "hello"
+        }
+        let x: text = vibe myFunc m default
+      `);
+      expect(errors).toContain("Cannot use function 'myFunc' as prompt");
+    });
+
+    test('vibe with another function as prompt errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function getQuestion() {
+          return "question"
+        }
+        let x: text = vibe getQuestion m default
+      `);
+      expect(errors).toContain("Cannot use function 'getQuestion' as prompt");
+    });
+
+    test('vibe with function as prompt errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function generate() {
+          return "code"
+        }
+        let x: text = vibe generate m default
+      `);
+      expect(errors).toContain("Cannot use function 'generate' as prompt");
+    });
+  });
+
+  // ============================================================================
+  // Undefined variables as prompts
+  // ============================================================================
+
+  describe('undefined variables as prompts', () => {
+    test('vibe with undefined variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe undefinedVar m default
+      `);
+      expect(errors).toContain("'undefinedVar' is not defined");
+    });
+
+    test('vibe with missing variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe missingQuestion m default
+      `);
+      expect(errors).toContain("'missingQuestion' is not defined");
+    });
+
+    test('vibe with undefined variable errors', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        let x: text = vibe notDefined m default
+      `);
+      expect(errors).toContain("'notDefined' is not defined");
+    });
+  });
+
+  // ============================================================================
+  // Function parameters as prompts
+  // ============================================================================
+
+  describe('function parameters as prompts', () => {
+    test('vibe with function parameter is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function askAI(question: text): text {
+          return vibe question m default
+        }
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with message parameter is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function getUserInput(message: text): text {
+          return vibe message m default
+        }
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with function parameter is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function generateCode(instruction: text): text {
+          return vibe instruction m default
+        }
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  // ============================================================================
+  // Call expressions as prompts (valid - returns text at runtime)
+  // ============================================================================
+
+  describe('call expressions as prompts', () => {
+    test('vibe with function call as prompt is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function getQuestion(): text {
+          return "What is 2+2?"
+        }
+        let x: text = vibe getQuestion() m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with buildPrompt function call is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function buildPrompt(): text {
+          return "Enter name:"
+        }
+        let x: text = vibe buildPrompt() m default
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('vibe with function call as prompt is valid', () => {
+      const errors = getErrors(`
+        ${modelDecl}
+        function getInstruction(): text {
+          return "Generate code"
+        }
+        let x: text = vibe getInstruction() m default
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+});

package/src/semantic/test/scoping.test.ts

@@ -0,0 +1,312 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Analysis - Scoping', () => {
+  // ============================================================================
+  // Block scope isolation
+  // ============================================================================
+
+  test('variable in block not accessible outside', () => {
+    const ast = parse(`
+if true {
+  let x = "inside"
+}
+let y = x
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'x' is not defined");
+  });
+
+  test('variable in else block not accessible outside', () => {
+    const ast = parse(`
+if false {
+  let a = "if"
+} else {
+  let b = "else"
+}
+let x = b
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'b' is not defined");
+  });
+
+  test('variable in nested block not accessible outside', () => {
+    const ast = parse(`
+if true {
+  if true {
+    let deep = "nested"
+  }
+  let x = deep
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'deep' is not defined");
+  });
+
+  // ============================================================================
+  // Function scope isolation
+  // ============================================================================
+
+  test('variable in function not accessible outside', () => {
+    const ast = parse(`
+function test() {
+  let x = "inside"
+  return x
+}
+let y = x
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'x' is not defined");
+  });
+
+  test('parameter not accessible outside function', () => {
+    const ast = parse(`
+function greet(name: text): text {
+  return name
+}
+let x = name
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'name' is not defined");
+  });
+
+  // ============================================================================
+  // Outer scope access
+  // ============================================================================
+
+  test('block can access outer scope', () => {
+    const ast = parse(`
+let x = "outer"
+if true {
+  let y = x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('function can access outer scope', () => {
+    const ast = parse(`
+let x = "outer"
+function test() {
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('nested block can access all outer scopes', () => {
+    const ast = parse(`
+let a = "level1"
+if true {
+  let b = "level2"
+  if true {
+    let c = a
+    let d = b
+  }
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Function parameter access
+  // ============================================================================
+
+  test('function body can access parameters', () => {
+    const ast = parse(`
+function add(a: text): text {
+  return a
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('multiple parameters accessible', () => {
+    const ast = parse(`
+function greet(first: text, last: text): text {
+  let full = first
+  return last
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('nested block in function can access parameters', () => {
+    const ast = parse(`
+function test(x: text, flag: boolean): text {
+  if flag {
+    return x
+  }
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Model scope
+  // ============================================================================
+
+  test('model accessible in same scope', () => {
+    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('model accessible in nested function', () => {
+    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);
+  });
+
+  test('model accessible in nested block', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+if true {
+  let x: text = vibe "prompt" myModel default
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Complex scoping scenarios
+  // ============================================================================
+
+  test('same name in parallel blocks', () => {
+    const ast = parse(`
+if true {
+  let x = "first"
+}
+if true {
+  let x = "second"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('shadowing and access in same function', () => {
+    const ast = parse(`
+let x = "outer"
+function test() {
+  let y = x
+  let x = "inner"
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('multiple functions with same local variable names', () => {
+    const ast = parse(`
+function first() {
+  let x = "a"
+  return x
+}
+function second() {
+  let x = "b"
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Nested function restrictions
+  // ============================================================================
+
+  test('function inside if block is not allowed', () => {
+    const ast = parse(`
+let name = "outer"
+if true {
+  function greet(name: text): text {
+    return name
+  }
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Functions can only be declared at global scope');
+  });
+
+  test('function inside function is not allowed', () => {
+    const ast = parse(`
+function outer() {
+  function inner() {
+    return "nested"
+  }
+  return inner()
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Functions can only be declared at global scope');
+  });
+
+  test('function inside else block is not allowed', () => {
+    const ast = parse(`
+if false {
+  let x = "if"
+} else {
+  function helper() {
+    return "help"
+  }
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Functions can only be declared at global scope');
+  });
+
+  test('deeply nested function is not allowed', () => {
+    const ast = parse(`
+function outer() {
+  if true {
+    function deeplyNested() {
+      return "deep"
+    }
+  }
+  return "outer"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Functions can only be declared at global scope');
+  });
+
+  test('function at global scope is allowed', () => {
+    const ast = parse(`
+function topLevel(): text {
+  return "allowed"
+}
+let result = topLevel()
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});