@vibe-lang/runtime 0.2.5

package/src/parser/test/errors/error-locations.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+import { ParserError, LexerError } from '../../../errors';
+
+describe('Error Locations', () => {
+  // ============================================================================
+  // Parser error locations
+  // ============================================================================
+
+  test('missing closing brace reports error', () => {
+    try {
+      parse(`
+let x = "first"
+let y = "second"
+if condition {
+  let z = "inside"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      // EOF token may not have line info, but error should exist
+      expect(err.location).toBeDefined();
+    }
+  });
+
+  test('unexpected token reports correct line and column', () => {
+    try {
+      parse(`
+let a = "one"
+let b = "two"
+let = "missing identifier"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.location?.line).toBe(4);
+      expect(err.location?.column).toBe(5); // position of '='
+    }
+  });
+
+  test('missing function body reports correct line', () => {
+    try {
+      parse(`
+let setup = "before"
+
+function broken()
+
+let after = "this line"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.location?.line).toBe(6); // 'let' on line 6 instead of '{'
+    }
+  });
+
+  test('invalid expression in nested block reports correct line', () => {
+    try {
+      parse(`
+function outer() {
+  let a = "first"
+  if condition {
+    let b = = "double equals"
+  }
+}
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.location?.line).toBe(5);
+    }
+  });
+
+  test('unclosed string in call reports correct line', () => {
+    try {
+      parse(`
+let x = "before"
+let y = "middle"
+foo("unclosed
+let z = "after"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      // Unclosed string is a lexer error
+      expect(e).toBeInstanceOf(LexerError);
+      const err = e as LexerError;
+      // Lexer reports error on the line after the unclosed string
+      expect(err.location?.line).toBe(5);
+    }
+  });
+
+  test('missing closing brace in function reports error', () => {
+    try {
+      parse(`
+function test() {
+  let a = "one"
+  let b = "two"
+  let c = "three"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      // EOF token may not have line info, but error should exist
+      expect(err.location).toBeDefined();
+    }
+  });
+
+  // ============================================================================
+  // Lexer error locations
+  // ============================================================================
+
+  test('unclosed string reports correct line', () => {
+    try {
+      parse(`
+let a = "valid"
+let b = "also valid"
+let c = "unclosed
+let d = "never reached"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(LexerError);
+      const err = e as LexerError;
+      // Lexer reports error on the line after the unclosed string
+      expect(err.location?.line).toBe(5);
+    }
+  });
+
+  test('unclosed string with single quotes reports correct line', () => {
+    try {
+      parse(`
+let first = 'ok'
+let second = 'also ok'
+let third = 'not closed
+let fourth = 'never seen'
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(LexerError);
+      const err = e as LexerError;
+      // Lexer reports error on the line after the unclosed string
+      expect(err.location?.line).toBe(5);
+    }
+  });
+
+  // ============================================================================
+  // Error formatting
+  // ============================================================================
+
+  test('format() includes source context', () => {
+    try {
+      parse(`
+let valid = "ok"
+let broken =
+let after = "never"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      const formatted = err.format();
+      expect(formatted).toContain('[vibe:');
+      expect(formatted).toContain('4:'); // line 4 (where 'let after' is)
+    }
+  });
+
+  test('format() shows caret pointing to error', () => {
+    try {
+      parse(`
+let x = "hello"
+let y = "world"
+function () {
+  return "missing name"
+}
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      const formatted = err.format();
+      expect(formatted).toContain('^'); // caret indicator
+      expect(formatted).toContain('|'); // line separator
+    }
+  });
+
+  // ============================================================================
+  // Column accuracy
+  // ============================================================================
+
+  test('column points to exact token position', () => {
+    try {
+      parse(`
+let validName = "ok"
+let    = "missing identifier"
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.location?.line).toBe(3);
+      expect(err.location?.column).toBe(8); // position of '=' after spaces
+    }
+  });
+
+  test('deeply nested error has correct location', () => {
+    try {
+      parse(`
+function level1() {
+  function level2() {
+    if a {
+      if b {
+        let x = ,
+      }
+    }
+  }
+}
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.location?.line).toBe(6);
+    }
+  });
+});

package/src/parser/test/errors/invalid-expressions.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Invalid Expressions', () => {
+  // ============================================================================
+  // Invalid call expressions
+  // ============================================================================
+
+  test('call with leading comma', () => {
+    expect(() => parse(`
+foo(, "hello")
+`)).toThrow();
+  });
+
+  test('call with trailing comma', () => {
+    expect(() => parse(`
+foo("hello",)
+`)).toThrow();
+  });
+
+  test('call with double comma', () => {
+    expect(() => parse(`
+foo("a",, "b")
+`)).toThrow();
+  });
+
+  test('call with only comma', () => {
+    expect(() => parse(`
+foo(,)
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Invalid function parameters
+  // ============================================================================
+
+  test('function params with leading comma', () => {
+    expect(() => parse(`
+function test(, a) {
+  return a
+}
+`)).toThrow();
+  });
+
+  test('function params with trailing comma', () => {
+    expect(() => parse(`
+function test(a,) {
+  return a
+}
+`)).toThrow();
+  });
+
+  test('function params with double comma', () => {
+    expect(() => parse(`
+function test(a,, b) {
+  return a
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Invalid primary expressions
+  // ============================================================================
+
+  test('empty parentheses as expression', () => {
+    expect(() => parse(`
+let x = ()
+`)).toThrow();
+  });
+
+  test('just equals sign', () => {
+    expect(() => parse(`
+=
+`)).toThrow();
+  });
+
+  test('just comma', () => {
+    expect(() => parse(`
+,
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Invalid do/vibe expressions
+  // ============================================================================
+
+  test('vibe with equals instead of expression', () => {
+    expect(() => parse(`
+let x = vibe =
+`)).toThrow();
+  });
+
+  test('vibe with comma instead of expression', () => {
+    expect(() => parse(`
+let x = vibe ,
+`)).toThrow();
+  });
+
+  test('vibe with closing paren', () => {
+    expect(() => parse(`
+let x = vibe )
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Invalid if conditions
+  // ============================================================================
+
+  test('if with empty condition', () => {
+    expect(() => parse(`
+if {
+  let x = "yes"
+}
+`)).toThrow();
+  });
+
+  test('if with equals as condition', () => {
+    expect(() => parse(`
+if = {
+  let x = "yes"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Invalid return expressions
+  // ============================================================================
+
+  test('return with comma', () => {
+    expect(() => parse(`
+function test() {
+  return ,
+}
+`)).toThrow();
+  });
+
+  test('return with only equals', () => {
+    expect(() => parse(`
+function test() {
+  return =
+}
+`)).toThrow();
+  });
+});

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

@@ -0,0 +1,126 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Missing Tokens', () => {
+  // ============================================================================
+  // const declaration
+  // ============================================================================
+
+  test('const missing equals and initializer', () => {
+    expect(() => parse(`
+const x
+`)).toThrow();
+  });
+
+  test('const missing initializer after equals', () => {
+    expect(() => parse(`
+const x =
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // let declaration
+  // ============================================================================
+
+  test('let missing initializer after equals', () => {
+    expect(() => parse(`
+let x =
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // function declaration
+  // ============================================================================
+
+  test('function missing closing paren', () => {
+    expect(() => parse(`
+function foo(
+`)).toThrow();
+  });
+
+  test('function missing body', () => {
+    expect(() => parse(`
+function foo()
+`)).toThrow();
+  });
+
+  test('function with params missing closing paren', () => {
+    expect(() => parse(`
+function greet(name
+`)).toThrow();
+  });
+
+  test('function missing opening paren', () => {
+    expect(() => parse(`
+function foo {
+  return "hello"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // if statement
+  // ============================================================================
+
+  test('if missing block', () => {
+    expect(() => parse(`
+if true
+`)).toThrow();
+  });
+
+  test('if with else missing block', () => {
+    expect(() => parse(`
+if true {
+  let x = "yes"
+} else
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // return statement
+  // ============================================================================
+
+  test('return with incomplete expression', () => {
+    expect(() => parse(`
+function test() {
+  return =
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // vibe expression
+  // ============================================================================
+
+  test('vibe missing prompt', () => {
+    expect(() => parse(`
+let x = do
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // vibe expression
+  // ============================================================================
+
+  test('vibe missing prompt', () => {
+    expect(() => parse(`
+let x = vibe
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // call expression
+  // ============================================================================
+
+  test('call missing closing paren', () => {
+    expect(() => parse(`
+foo(
+`)).toThrow();
+  });
+
+  test('call with args missing closing paren', () => {
+    expect(() => parse(`
+greet("hello"
+`)).toThrow();
+  });
+});

package/src/parser/test/errors/model-declaration.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parse';
+
+describe('Syntax Errors - Model Declaration', () => {
+  // ============================================================================
+  // Missing model components
+  // ============================================================================
+
+  test('model missing name', () => {
+    expect(() => parse(`
+model = {
+  name: "test"
+}
+`)).toThrow();
+  });
+
+  test('model missing equals sign', () => {
+    expect(() => parse(`
+model myModel {
+  name: "test"
+}
+`)).toThrow();
+  });
+
+  test('model missing object literal', () => {
+    expect(() => parse(`
+model myModel =
+`)).toThrow();
+  });
+
+  test('model with string instead of object', () => {
+    expect(() => parse(`
+model myModel = "not an object"
+`)).toThrow();
+  });
+
+  test('model with identifier instead of object', () => {
+    expect(() => parse(`
+model myModel = otherModel
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Object literal errors
+  // ============================================================================
+
+  test('model with unclosed brace', () => {
+    expect(() => parse(`
+model myModel = {
+  name: "test"
+`)).toThrow();
+  });
+
+  test('model with only opening brace', () => {
+    expect(() => parse(`
+model myModel = {
+`)).toThrow();
+  });
+
+  test('model missing opening brace', () => {
+    expect(() => parse(`
+model myModel = name: "test" }
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Property errors
+  // ============================================================================
+
+  test('property missing colon', () => {
+    expect(() => parse(`
+model myModel = {
+  name "test"
+}
+`)).toThrow();
+  });
+
+  test('property missing value', () => {
+    expect(() => parse(`
+model myModel = {
+  name:
+}
+`)).toThrow();
+  });
+
+  test('property with trailing comma only', () => {
+    expect(() => parse(`
+model myModel = {
+  ,
+}
+`)).toThrow();
+  });
+
+  test('property with double colon', () => {
+    expect(() => parse(`
+model myModel = {
+  name:: "test"
+}
+`)).toThrow();
+  });
+
+  test('property with equals instead of colon', () => {
+    expect(() => parse(`
+model myModel = {
+  name = "test"
+}
+`)).toThrow();
+  });
+
+  test('property key as string literal', () => {
+    expect(() => parse(`
+model myModel = {
+  "name": "test"
+}
+`)).toThrow();
+  });
+
+  test('property with missing key', () => {
+    expect(() => parse(`
+model myModel = {
+  : "test"
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Multiple properties errors
+  // ============================================================================
+
+  test('properties missing comma separator', () => {
+    expect(() => parse(`
+model myModel = {
+  name: "test"
+  apiKey: "key"
+}
+`)).toThrow();
+  });
+
+  test('properties with double comma', () => {
+    expect(() => parse(`
+model myModel = {
+  name: "test",,
+  apiKey: "key"
+}
+`)).toThrow();
+  });
+
+  test('trailing comma without next property', () => {
+    expect(() => parse(`
+model myModel = {
+  name: "test",
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Model keyword misuse
+  // ============================================================================
+
+  test('model as variable name', () => {
+    expect(() => parse(`
+let model = "test"
+`)).toThrow();
+  });
+
+  test('nested model in property', () => {
+    expect(() => parse(`
+model outer = {
+  inner: model nested = {}
+}
+`)).toThrow();
+  });
+
+  // ============================================================================
+  // Model with invalid property values
+  // ============================================================================
+
+  test('model property with unclosed string', () => {
+    expect(() => parse(`
+model myModel = {
+  name: "unclosed
+}
+`)).toThrow();
+  });
+});