@vibe-lang/runtime 0.2.5

package/src/parser/test/errors/nested-blocks.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Nested Blocks', () => {
+  // ============================================================================
+  // Missing closing braces at different levels
+  // ============================================================================
+
+  test('missing closing brace on outer function', () => {
+    expect(() => parse(`
+function outer() {
+  function inner() {
+    return "nested"
+  }
+`)).toThrow();
+  });
+
+  test('missing closing brace on inner function', () => {
+    expect(() => parse(`
+function outer() {
+  function inner() {
+    return "nested"
+}
+`)).toThrow();
+  });
+
+  test('missing closing brace on outer if', () => {
+    expect(() => parse(`
+if a {
+  if b {
+    let x = "nested"
+  }
+`)).toThrow();
+  });
+
+  test('missing closing brace on inner if', () => {
+    expect(() => parse(`
+if a {
+  if b {
+    let x = "nested"
+}
+`)).toThrow();
+  });
+
+  test('missing closing brace on deeply nested block', () => {
+    expect(() => parse(`
+{
+  {
+    {
+      let deep = "value"
+    }
+  }
+`)).toThrow();
+  });
+
+  test('missing middle closing brace', () => {
+    expect(() => parse(`
+{
+  {
+    let inner = "value"
+  }
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Missing closing braces in mixed nesting
+  // ============================================================================
+
+  test('function with unclosed if inside', () => {
+    expect(() => parse(`
+function test() {
+  if condition {
+    let x = "value"
+}
+`)).toThrow();
+  });
+
+  test('if with unclosed block inside', () => {
+    expect(() => parse(`
+if condition {
+  {
+    let x = "value"
+}
+`)).toThrow();
+  });
+
+  test('function with unclosed nested function', () => {
+    expect(() => parse(`
+function outer() {
+  function inner() {
+    if x {
+      return "deep"
+    }
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Multiple unclosed braces
+  // ============================================================================
+
+  test('two unclosed braces', () => {
+    expect(() => parse(`
+function test() {
+  if x {
+    let y = "value"
+`)).toThrow();
+  });
+
+  test('three unclosed braces', () => {
+    expect(() => parse(`
+function test() {
+  {
+    if x {
+      let y = "value"
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unclosed else blocks in nesting
+  // ============================================================================
+
+  test('unclosed else in nested if', () => {
+    expect(() => parse(`
+function test() {
+  if a {
+    let x = "yes"
+  } else {
+    let y = "no"
+}
+`)).toThrow();
+  });
+
+  test('unclosed else-if in nested structure', () => {
+    expect(() => parse(`
+function test() {
+  if a {
+    let x = "first"
+  } else if b {
+    let y = "second"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Extra closing braces
+  // ============================================================================
+
+  test('extra closing brace after nested blocks', () => {
+    expect(() => parse(`
+function test() {
+  if x {
+    let y = "value"
+  }
+}
+}
+`)).toThrow();
+  });
+
+  test('extra closing brace inside function', () => {
+    expect(() => parse(`
+function test() {
+  let x = "value"
+  }
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Misplaced braces
+  // ============================================================================
+
+  test('closing brace before opening in nested context', () => {
+    expect(() => parse(`
+function test() {
+  }
+  if x {
+    let y = "value"
+  }
+}
+`)).toThrow();
+  });
+
+  test('opening brace without statement in nesting', () => {
+    expect(() => parse(`
+function test() {
+  { {
+    let x = "value"
+  }
+}
+`)).toThrow(); // Missing closing brace for inner block
+  });
+
+  // ============================================================================
+  // Incomplete statements in nested blocks
+  // ============================================================================
+
+  test('incomplete let in nested block', () => {
+    expect(() => parse(`
+function test() {
+  if x {
+    let y =
+  }
+}
+`)).toThrow();
+  });
+
+  test('incomplete const in deeply nested block', () => {
+    expect(() => parse(`
+function outer() {
+  function inner() {
+    const x =
+  }
+}
+`)).toThrow();
+  });
+
+  test('incomplete function declaration in nested block', () => {
+    expect(() => parse(`
+function outer() {
+  function inner(
+  }
+}
+`)).toThrow();
+  });
+});

package/src/parser/test/errors/unclosed-delimiters.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Unclosed Delimiters', () => {
+  // ============================================================================
+  // Unclosed braces
+  // ============================================================================
+
+  test('unclosed block statement', () => {
+    expect(() => parse(`
+{
+  let x = "hello"
+`)).toThrow();
+  });
+
+  test('unclosed function body', () => {
+    expect(() => parse(`
+function foo() {
+  return "hello"
+`)).toThrow();
+  });
+
+  test('unclosed if block', () => {
+    expect(() => parse(`
+if true {
+  let x = "yes"
+`)).toThrow();
+  });
+
+  test('unclosed else block', () => {
+    expect(() => parse(`
+if true {
+  let x = "yes"
+} else {
+  let y = "no"
+`)).toThrow();
+  });
+
+  test('nested unclosed braces', () => {
+    expect(() => parse(`
+function outer() {
+  if true {
+    let x = "nested"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unclosed parentheses
+  // ============================================================================
+
+  test('unclosed function call', () => {
+    expect(() => parse(`
+foo("hello"
+`)).toThrow();
+  });
+
+  test('unclosed function params', () => {
+    expect(() => parse(`
+function greet(name, age
+`)).toThrow();
+  });
+
+  test('unclosed grouped expression', () => {
+    expect(() => parse(`
+let x = ("hello"
+`)).toThrow();
+  });
+
+  test('nested unclosed parens in call', () => {
+    expect(() => parse(`
+outer(inner("deep"
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unclosed strings
+  // ============================================================================
+
+  test('unclosed double quote string', () => {
+    expect(() => parse(`
+let x = "hello
+`)).toThrow();
+  });
+
+  test('unclosed single quote string', () => {
+    expect(() => parse(`
+let x = 'hello
+`)).toThrow();
+  });
+
+  test('unclosed string in function call', () => {
+    expect(() => parse(`
+greet("hello)
+`)).toThrow();
+  });
+
+  test('unclosed string in vibe expression', () => {
+    expect(() => parse(`
+let x = vibe "what is 2+2?
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Mixed unclosed delimiters
+  // ============================================================================
+
+  test('unclosed brace and paren', () => {
+    expect(() => parse(`
+function test() {
+  foo(
+}
+`)).toThrow();
+  });
+
+  test('unclosed string inside unclosed block', () => {
+    expect(() => parse(`
+{
+  let x = "hello
+`)).toThrow();
+  });
+});

package/src/parser/test/errors/unexpected-tokens.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Unexpected Tokens', () => {
+  // ============================================================================
+  // Missing identifiers after keywords
+  // ============================================================================
+
+  test('let missing identifier', () => {
+    expect(() => parse(`
+let = "hello"
+`)).toThrow();
+  });
+
+  test('const missing identifier', () => {
+    expect(() => parse(`
+const = "hello"
+`)).toThrow();
+  });
+
+  test('function missing name', () => {
+    expect(() => parse(`
+function() {
+  return "hello"
+}
+`)).toThrow();
+  });
+
+  test('function with keyword as name', () => {
+    expect(() => parse(`
+function let() {
+  return "hello"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Keywords in wrong positions
+  // ============================================================================
+
+  test('return outside function at top level', () => {
+    // Note: This may or may not throw depending on parser design
+    // Testing the parser's behavior
+    expect(() => parse(`
+return "hello"
+`)).not.toThrow(); // return is valid as a statement
+  });
+
+  test('break at top level', () => {
+    // break is syntactically valid, semantics checked at runtime
+    expect(() => parse(`
+break
+`)).not.toThrow();
+  });
+
+  test('else without if', () => {
+    expect(() => parse(`
+else {
+  let x = "no"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unexpected tokens in declarations
+  // ============================================================================
+
+  test('let with string instead of identifier', () => {
+    expect(() => parse(`
+let "name" = "value"
+`)).toThrow();
+  });
+
+  test('const with number-like token instead of identifier', () => {
+    expect(() => parse(`
+const 123 = "value"
+`)).toThrow();
+  });
+
+  test('function param is keyword', () => {
+    expect(() => parse(`
+function test(return) {
+  return "hello"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unexpected tokens in expressions
+  // ============================================================================
+
+  test('let inside expression', () => {
+    expect(() => parse(`
+let x = let y
+`)).toThrow();
+  });
+
+  test('equals in wrong position', () => {
+    expect(() => parse(`
+let x = = "hello"
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Unexpected tokens in blocks
+  // ============================================================================
+
+  test('closing brace without opening', () => {
+    expect(() => parse(`
+let x = "hello"
+}
+`)).toThrow();
+  });
+
+  test('closing paren without opening', () => {
+    expect(() => parse(`
+let x = "hello")
+`)).toThrow();
+  });
+});

package/src/parser/test/import-export.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../parse';
+import type * as AST from '../../ast';
+
+describe('Parser - Import Declarations', () => {
+  test('single import from TypeScript file', () => {
+    const source = `import { add } from "./math.ts"`;
+    const ast = parse(source);
+
+    expect(ast.body).toHaveLength(1);
+    const importDecl = ast.body[0] as AST.ImportDeclaration;
+    expect(importDecl.type).toBe('ImportDeclaration');
+    expect(importDecl.specifiers).toEqual([{ imported: 'add', local: 'add' }]);
+    expect(importDecl.source).toBe('./math.ts');
+    expect(importDecl.sourceType).toBe('ts');
+  });
+
+  test('multiple imports from TypeScript file', () => {
+    const source = `import { add, subtract, multiply } from "./math.ts"`;
+    const ast = parse(source);
+
+    const importDecl = ast.body[0] as AST.ImportDeclaration;
+    expect(importDecl.specifiers).toEqual([
+      { imported: 'add', local: 'add' },
+      { imported: 'subtract', local: 'subtract' },
+      { imported: 'multiply', local: 'multiply' },
+    ]);
+    expect(importDecl.sourceType).toBe('ts');
+  });
+
+  test('import from Vibe file', () => {
+    const source = `import { greet } from "./utils.vibe"`;
+    const ast = parse(source);
+
+    const importDecl = ast.body[0] as AST.ImportDeclaration;
+    expect(importDecl.specifiers).toEqual([{ imported: 'greet', local: 'greet' }]);
+    expect(importDecl.source).toBe('./utils.vibe');
+    expect(importDecl.sourceType).toBe('vibe');
+  });
+
+  test('import from JavaScript file', () => {
+    const source = `import { helper } from "./helper.js"`;
+    const ast = parse(source);
+
+    const importDecl = ast.body[0] as AST.ImportDeclaration;
+    expect(importDecl.sourceType).toBe('ts'); // JS files are treated as TS
+  });
+
+  test('multiple import statements', () => {
+    const source = `
+      import { add } from "./math.ts"
+      import { greet } from "./greet.vibe"
+      let x = add("a", "b")
+    `;
+    const ast = parse(source);
+
+    expect(ast.body).toHaveLength(3);
+    expect((ast.body[0] as AST.ImportDeclaration).type).toBe('ImportDeclaration');
+    expect((ast.body[1] as AST.ImportDeclaration).type).toBe('ImportDeclaration');
+    expect((ast.body[2] as AST.LetDeclaration).type).toBe('LetDeclaration');
+  });
+});
+
+describe('Parser - Export Declarations', () => {
+  test('export function', () => {
+    const source = `
+      export function greet(name: text): text {
+        return vibe "Hello {name}" gpt default
+      }
+    `;
+    const ast = parse(source);
+
+    expect(ast.body).toHaveLength(1);
+    const exportDecl = ast.body[0] as AST.ExportDeclaration;
+    expect(exportDecl.type).toBe('ExportDeclaration');
+    expect(exportDecl.declaration.type).toBe('FunctionDeclaration');
+    expect((exportDecl.declaration as AST.FunctionDeclaration).name).toBe('greet');
+  });
+
+  test('export let', () => {
+    const source = `export let counter = "0"`;
+    const ast = parse(source);
+
+    const exportDecl = ast.body[0] as AST.ExportDeclaration;
+    expect(exportDecl.type).toBe('ExportDeclaration');
+    expect(exportDecl.declaration.type).toBe('LetDeclaration');
+    expect((exportDecl.declaration as AST.LetDeclaration).name).toBe('counter');
+  });
+
+  test('export const', () => {
+    const source = `export const API_KEY = "secret123"`;
+    const ast = parse(source);
+
+    const exportDecl = ast.body[0] as AST.ExportDeclaration;
+    expect(exportDecl.type).toBe('ExportDeclaration');
+    expect(exportDecl.declaration.type).toBe('ConstDeclaration');
+    expect((exportDecl.declaration as AST.ConstDeclaration).name).toBe('API_KEY');
+  });
+
+  test('export model', () => {
+    const source = `export model gpt = { name: "gpt-4" }`;
+    const ast = parse(source);
+
+    const exportDecl = ast.body[0] as AST.ExportDeclaration;
+    expect(exportDecl.type).toBe('ExportDeclaration');
+    expect(exportDecl.declaration.type).toBe('ModelDeclaration');
+    expect((exportDecl.declaration as AST.ModelDeclaration).name).toBe('gpt');
+  });
+
+  test('multiple exports', () => {
+    const source = `
+      export function add(a: text, b: text): text {
+        return ts(a, b) { return a + b }
+      }
+      export const PI = "3.14159"
+      export model gpt = { name: "gpt-4" }
+    `;
+    const ast = parse(source);
+
+    expect(ast.body).toHaveLength(3);
+    expect((ast.body[0] as AST.ExportDeclaration).declaration.type).toBe('FunctionDeclaration');
+    expect((ast.body[1] as AST.ExportDeclaration).declaration.type).toBe('ConstDeclaration');
+    expect((ast.body[2] as AST.ExportDeclaration).declaration.type).toBe('ModelDeclaration');
+  });
+});
+
+describe('Parser - Import and Export Combined', () => {
+  test('import and export in same file', () => {
+    const source = `
+      import { helper } from "./helper.ts"
+
+      export function greet(name: text): text {
+        let greeting = helper(name)
+        return vibe "{greeting}" gpt default
+      }
+    `;
+    const ast = parse(source);
+
+    expect(ast.body).toHaveLength(2);
+    expect((ast.body[0] as AST.ImportDeclaration).type).toBe('ImportDeclaration');
+    expect((ast.body[1] as AST.ExportDeclaration).type).toBe('ExportDeclaration');
+  });
+});