Merge pull request #1 from KevinBatdorf/add-tests-for-compile-from-source

Author: KevinBatdorf

README.md

@@ -89,10 +89,18 @@ run(bytes);
 
 ## Types
 
-All major types are exported:
+All error classes and major types are exported:
 
 ```ts
-import type { AST, Token, CompilerErrorType, ParseErrorType, TokenErrorType, RunFunction } from "pinky-compiler";
+import type {
+    CompilerError,
+    ParseError,
+    TokenError,
+    type AST,
+    type Token,
+    type CompileFromSourceResult,
+    type RunFunction
+} from "pinky-compiler";
 ```
 
 Additionally, you can import the syntax types listed [here](https://github.com/KevinBatdorf/pinky-compiler/blob/main/src/index.ts).

src/compiler.ts

@@ -45,7 +45,7 @@ import {
 import type { AST } from "./parser";
 import type { Expression, Statement } from "./syntax";
 
-class CompilerError extends Error {
+export class CompilerError extends Error {
 	line: number;
 	column: number;
 	tokenLength: number;

src/from-source.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "vitest";
+import { CompilerError, compileFromSource, ParseError, TokenError } from ".";
+
+describe("compileFromSource (discriminated union)", () => {
+	test("returns valid bytes and no error for correct source", () => {
+		const source = 'println "hello world"';
+		const result = compileFromSource(source);
+
+		expect(result.errorType).toBeNull();
+		expect(result.error).toBeNull();
+		expect(result.bytes).toBeInstanceOf(Uint8Array);
+		expect(result.strings).toBeInstanceOf(Uint8Array);
+	});
+
+	test("returns TokenError for invalid token", () => {
+		const source = 'println "unterminated string';
+		const result = compileFromSource(source);
+
+		expect(result.errorType).toBe("TokenError");
+		expect(result.error).toBeInstanceOf(TokenError);
+		expect(result.bytes).toBeNull();
+		expect(result.strings).toBeNull();
+	});
+
+	test("returns ParseError for invalid syntax", () => {
+		const source = "print )";
+		const result = compileFromSource(source);
+
+		expect(result.errorType).toBe("ParseError");
+		expect(result.error).toBeInstanceOf(ParseError);
+		expect(result.bytes).toBeNull();
+		expect(result.strings).toBeNull();
+	});
+
+	test("returns CompilerError for semantic error", () => {
+		const source = "print x";
+		const result = compileFromSource(source);
+
+		expect(result.errorType).toBe("CompilerError");
+		expect(result.error).toBeInstanceOf(CompilerError);
+		expect(result.bytes).toBeNull();
+		expect(result.strings).toBeNull();
+	});
+});

src/index.ts

@@ -1,33 +1,73 @@
-import { compile } from "./compiler";
+import { type CompilerError, compile } from "./compiler";
 import { loadWasm } from "./compiler/exports";
-import { tokenize } from "./lexer";
-import { parse } from "./parser";
+import { type TokenError, tokenize } from "./lexer";
+import { type ParseError, parse } from "./parser";
 
-export type { CompilerErrorType } from "./compiler";
-export { compile } from "./compiler";
-export type { RunFunction } from "./compiler/exports";
-export { loadWasm } from "./compiler/exports";
-export type { TokenErrorType } from "./lexer";
-export { tokenize } from "./lexer";
-export type { AST, ParseErrorType } from "./parser";
-export { parse } from "./parser";
+export { CompilerError, compile } from "./compiler";
+export { loadWasm, type RunFunction } from "./compiler/exports";
+export { TokenError, tokenize } from "./lexer";
+export { type AST, ParseError, parse } from "./parser";
 export * from "./syntax";
 export type { Token } from "./tokens";
 
+export type CompileFromSourceResult =
+	| { errorType: null; error: null; bytes: Uint8Array; strings: Uint8Array }
+	| { errorType: "TokenError"; error: TokenError; bytes: null; strings: null }
+	| { errorType: "ParseError"; error: ParseError; bytes: null; strings: null }
+	| {
+			errorType: "CompilerError";
+			error: CompilerError;
+			bytes: null;
+			strings: null;
+	  };
+
 /**
  * Compiles Pinky source code from a string.
  * This function tokenizes the source code, parses the tokens into an AST,
  * and then compiles the AST into WebAssembly binary.
  *
  * ```
  * const source = "x := 42 print(x)";
- * const wasmBytes = compileFromSource(source);
+ * const { bytes } = compileFromSource(source);
  * ```
  */
-export const compileFromSource = (source: string) => {
-	const { tokens } = tokenize(source);
-	const { ast } = parse(tokens);
-	return compile(ast);
+export const compileFromSource = (source: string): CompileFromSourceResult => {
+	const { tokens, error: tokenError } = tokenize(source);
+	if (tokenError) {
+		return {
+			bytes: null,
+			strings: null,
+			errorType: "TokenError",
+			error: tokenError,
+		};
+	}
+
+	const { ast, error: parseError } = parse(tokens);
+	if (parseError) {
+		return {
+			bytes: null,
+			strings: null,
+			errorType: "ParseError",
+			error: parseError,
+		};
+	}
+
+	const { bytes, meta, error: compilerError } = compile(ast);
+	if (compilerError) {
+		return {
+			bytes: null,
+			strings: null,
+			errorType: "CompilerError",
+			error: compilerError,
+		};
+	}
+
+	return {
+		bytes,
+		strings: meta?.strings ?? null,
+		errorType: null,
+		error: compilerError,
+	};
 };
 
 /**

src/lexer.test.ts

@@ -12,6 +12,7 @@ import {
 	lookahead,
 	match,
 	peek,
+	TokenError,
 } from "./lexer";
 
 test("isAlpha", () => {
@@ -420,11 +421,7 @@ test("should error on invalid input", () => {
 		{ type: "RPAREN", value: ")", start: 10, end: 11, column: 11, line: 1 },
 		{ type: "EOF", value: "", start: 11, end: 11, column: 12, line: 1 },
 	]);
-	expect(error).toEqual({
-		line: 1,
-		column: 12,
-		message: "Unexpected character ':'",
-	});
+	expect(error).toEqual(new TokenError("Unexpected character ':'", 1, 12));
 });
 
 test("should tokenize >= and <=", () => {

src/lexer.ts

@@ -1,10 +1,16 @@
 import { keywords, type Token, tokenTypes } from "./tokens";
 
-export type TokenErrorType = null | {
+export class TokenError extends Error {
 	line: number;
 	column: number;
-	message: string;
-};
+	constructor(message: string, line: number, column: number) {
+		super(message);
+		this.name = "TokenError";
+		this.line = line;
+		this.column = column;
+	}
+}
+export type TokenErrorType = null | TokenError;
 
 export const isAlpha = (char: string): boolean =>
 	(char >= "a" && char <= "z") || (char >= "A" && char <= "Z") || char === "_";
@@ -125,11 +131,12 @@ export const tokenize = (
 	const errorReturn = (
 		message: string,
 		details?: { line?: number; column?: number },
-	): TokenErrorType => ({
-		message,
-		line: details?.line || pos.line,
-		column: details?.column || pos.column,
-	});
+	): TokenErrorType =>
+		new TokenError(
+			message,
+			details?.line || pos.line,
+			details?.column || pos.column,
+		);
 
 	while (!isEndOfFile(peek(src, pos.current))) {
 		const ch = peek(src, pos.current);

src/parser.ts

@@ -12,7 +12,7 @@ import { symbolForTokenType, type Token, type TokenType } from "./tokens";
 
 type ParserState = { tokens: Token[]; current: number };
 export type AST = Program;
-class ParseError extends Error {
+export class ParseError extends Error {
 	body: Program;
 	line: number;
 	column: number;