debug/app.ona

@@ -1,23 +1,24 @@
 
-i = 0
+# Test comment.
 
-while i < 5:
+pos = @vec3(10, 20, 0.3)
-	@print("hello, world")
+coord = pos.xz
 
-	i = i + 1
+options = {
-end
+	.title = "Afterglow",
-
-if i > 6:
-	@print("`i` greater than `6`")
-elif i == 4:
-	@print("`i` is equal to `4`")
-else:
-	@print("i'unno")
-end
-
-return {
-	.title = "Game",
 	.width = 1280,
 	.height = 800,
 	.tick_rate = 60,
+
+	["foo"] = "bar",
+	[42] = "42",
 }
+
+options["foo"] = "rab"
+options[42] = "24"
+
+@print(options.title)
+@print(options["foo"])
+@print(options[42])
+
+return options

source/ona/kym.zig

@@ -1,4 +1,4 @@
-const ast = @import("./kym/ast.zig");
+const Ast = @import("./kym/Ast.zig");
 
 const coral = @import("coral");
 
@@ -36,7 +36,6 @@ pub const RuntimeEnv = struct {
 		};
 
 		const Opcode = union (enum) {
-			pop,
 			push_nil,
 			push_true,
 			push_false,
@@ -62,9 +61,6 @@ pub const RuntimeEnv = struct {
 			clt,
 			cge,
 			cle,
-
-			jt: u32,
-			jf: u32,
 		};
 
 		const OpcodeList = coral.list.Stack(Opcode);
@@ -73,7 +69,7 @@ pub const RuntimeEnv = struct {
 			local_identifiers_buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
 			local_identifiers_count: u8 = 0,
 
-			fn compile_expression(self: *CompilationUnit, chunk: *Chunk, expression: ast.Expression) RuntimeError!void {
+			fn compile_expression(self: *CompilationUnit, chunk: *Chunk, expression: Ast.Expression) RuntimeError!void {
 				const number_format = coral.utf8.DecimalFormat{
 					.delimiter = "_",
 					.positive_prefix = .none,
@@ -136,9 +132,9 @@ pub const RuntimeEnv = struct {
 							.subtraction => .sub,
 							.multiplication => .mul,
 							.divsion => .div,
-							.greater_equals_comparison => .cge,
+							.greater_equals_comparison => .eql,
 							.greater_than_comparison => .cgt,
-							.equals_comparison => .eql,
+							.equals_comparison => .cge,
 							.less_than_comparison => .clt,
 							.less_equals_comparison => .cle,
 						});
@@ -204,23 +200,21 @@ pub const RuntimeEnv = struct {
 
 					.local_get => |local_get| {
 						try chunk.opcodes.push_one(.{
-							.push_local = self.resolve_local(local_get.identifier) orelse {
+							.push_local = self.resolve_local(local_get) orelse {
 								return chunk.env.raise(error.OutOfMemory, "undefined local");
 							},
 						});
 					},
 
 					.local_set => |local_set| {
-						try self.compile_expression(chunk, local_set.value_expression.*);
+						if (self.resolve_local(local_set)) |index| {
-
-						if (self.resolve_local(local_set.identifier)) |index| {
 							try chunk.opcodes.push_one(.{.local_set = index});
 						} else {
 							if (self.local_identifiers_count == self.local_identifiers_buffer.len) {
 								return chunk.env.raise(error.BadSyntax, "chunks may have a maximum of 255 locals");
 							}
 
-							self.local_identifiers_buffer[self.local_identifiers_count] = local_set.identifier;
+							self.local_identifiers_buffer[self.local_identifiers_count] = local_set;
 							self.local_identifiers_count += 1;
 						}
 					},
@@ -261,62 +255,17 @@ pub const RuntimeEnv = struct {
 				}
 			}
 
-			fn compile_statement(self: *CompilationUnit, chunk: *Chunk, statement: ast.Statement) RuntimeError!void {
+			fn compile_statement(self: *CompilationUnit, chunk: *Chunk, statement: Ast.Statement) RuntimeError!void {
 				switch (statement) {
 					.@"return" => |@"return"| {
-						if (@"return") |expression| {
+						if (@"return".expression) |expression| {
 							try self.compile_expression(chunk, expression);
 						} else {
 							try chunk.opcodes.push_one(.push_nil);
 						}
 					},
 
-					.block => |block| {
+					.expression => |expression| try self.compile_expression(chunk, expression),
-						for (block.values) |block_statement| {
-							try self.compile_statement(chunk, block_statement);
-						}
-					},
-
-					.@"while" => |@"while"| {
-						try self.compile_expression(chunk, @"while".condition_expression);
-						try chunk.opcodes.push_one(.{.jf = 0});
-
-						const origin_index = @as(u32, @intCast(chunk.opcodes.values.len - 1));
-
-						for (@"while".block_statements.values) |block_statement| {
-							try self.compile_statement(chunk, block_statement);
-						}
-
-						chunk.opcodes.values[origin_index].jf = @intCast(chunk.opcodes.values.len - 1);
-
-						try self.compile_expression(chunk, @"while".condition_expression);
-						try chunk.opcodes.push_one(.{.jt = origin_index});
-					},
-
-					.@"if" => |@"if"| {
-						try self.compile_expression(chunk, @"if".condition_expression);
-						try chunk.opcodes.push_one(.{.jf = 0});
-
-						const origin_index = @as(u32, @intCast(chunk.opcodes.values.len - 1));
-
-						for (@"if".block_statements.values) |block_statement| {
-							try self.compile_statement(chunk, block_statement);
-						}
-
-						chunk.opcodes.values[origin_index].jf = @intCast(chunk.opcodes.values.len - 1);
-
-						if (@"if".else_statement) |else_statement| {
-							try self.compile_statement(chunk, else_statement.*);
-						}
-					},
-
-					.expression => |expression| {
-						try self.compile_expression(chunk, expression);
-
-						if (expression == .invoke) {
-							try chunk.opcodes.push_one(.pop);
-						}
-					},
 				}
 			}
 
@@ -339,10 +288,10 @@ pub const RuntimeEnv = struct {
 			}
 		};
 
-		fn compile(self: *Chunk, statements: []const ast.Statement) RuntimeError!void {
+		fn compile(self: *Chunk, ast: Ast) RuntimeError!void {
 			var unit = CompilationUnit{};
 
-			for (statements) |statement| {
+			for (ast.list_statements()) |statement| {
 				try unit.compile_statement(self, statement);
 			}
 		}
@@ -373,16 +322,8 @@ pub const RuntimeEnv = struct {
 
 			defer coral.debug.assert(self.env.frames.pop() != null);
 
-			var opcode_cursor = @as(u32, 0);
+			for (self.opcodes.values) |opcode| {
-
+				switch (opcode) {
-			while (opcode_cursor < self.opcodes.values.len) : (opcode_cursor += 1) {
-				switch (self.opcodes.values[opcode_cursor]) {
-					.pop => {
-						if (try self.pop_local()) |ref| {
-							self.env.discard(ref);
-						}
-					},
-
 					.push_nil => try self.env.locals.push_one(null),
 					.push_true => try self.env.locals.push_one(try self.env.new_boolean(true)),
 					.push_false => try self.env.locals.push_one(try self.env.new_boolean(false)),
@@ -396,10 +337,6 @@ pub const RuntimeEnv = struct {
 					},
 
 					.push_local => |push_local| {
-						if (push_local >= self.env.locals.values.len) {
-							return self.env.raise(error.IllegalState, "invalid local");
-						}
-
 						if (self.env.locals.values[push_local]) |local| {
 							try self.env.locals.push_one(try self.env.acquire(local));
 						} else {
@@ -464,11 +401,15 @@ pub const RuntimeEnv = struct {
 					},
 
 					.object_get => {
-						const index = try self.env.expect(try self.pop_local());
+						const index = (try self.pop_local()) orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid index");
+						};
 
 						defer self.env.discard(index);
 
-						const indexable = try self.env.expect(try self.pop_local());
+						const indexable = (try self.pop_local()) orelse {
+							return self.env.raise(error.TypeMismatch, "nil is not a valid indexable");
+						};
 
 						defer self.env.discard(indexable);
 
@@ -850,29 +791,6 @@ pub const RuntimeEnv = struct {
 						}));
 					},
 
-					.jf => |jf| {
-						const condition = (try self.pop_local()) orelse {
-							opcode_cursor = jf;
-
-							continue;
-						};
-
-						self.env.discard(condition);
-
-						if (!condition.is_truthy()) {
-							opcode_cursor = jf;
-						}
-					},
-
-					.jt => |jt| {
-						const condition = (try self.pop_local()) orelse continue;
-
-						self.env.discard(condition);
-
-						if (condition.is_truthy()) {
-							opcode_cursor = jt;
-						}
-					},
 				}
 			}
 
@@ -1126,18 +1044,20 @@ pub const RuntimeEnv = struct {
 		defer self.allocator.deallocate(file_data);
 
 		const file_name = file_path.to_string() orelse "<script>";
+		var ast = Ast.make(self.allocator, file_name);
+
+		defer ast.free();
+
+		ast.parse(file_data) catch |parse_error| return switch (parse_error) {
+			error.BadSyntax => self.raise(error.BadSyntax, ast.error_message()),
+			error.OutOfMemory => error.OutOfMemory,
+		};
+
 		var chunk = try Chunk.make(self, file_name);
 
 		defer chunk.free();
 
-		var ast_tree = ast.Tree.make(self.allocator, file_name);
+		try chunk.compile(ast);
-
-		defer ast_tree.free();
-
-		try chunk.compile(ast_tree.parse(file_data) catch |parse_error| return switch (parse_error) {
-			error.BadSyntax => self.raise(error.BadSyntax, ast_tree.error_message()),
-			error.OutOfMemory => error.OutOfMemory,
-		});
 
 		return chunk.execute();
 	}
@@ -1592,21 +1512,6 @@ pub const RuntimeRef = opaque {
 			.dynamic => true,
 		};
 	}
-
-	pub fn typename(self: *const RuntimeRef) []const coral.io.Byte {
-		return switch (self.object().payload) {
-			.false => "false",
-			.true => "true",
-			.float => "float",
-			.fixed => "fixed",
-			.symbol => "symbol",
-			.vector2 => "vector2",
-			.vector3 => "vector3",
-			.syscall => "syscall",
-			.string => "string",
-			.dynamic => "dynamic",
-		};
-	}
 };
 
 pub const Syscall = fn (env: *RuntimeEnv) RuntimeError!?*RuntimeRef;

source/ona/kym/Ast.zig

@@ -0,0 +1,567 @@
+const coral = @import("coral");
+
+const tokens = @import("./tokens.zig");
+
+name: []const coral.io.Byte,
+allocator: coral.io.Allocator,
+arena: coral.arena.Stacking,
+statements: Statement.List,
+error_buffer: coral.list.ByteStack,
+tokenizer: tokens.Tokenizer,
+
+pub const Expression = union (enum) {
+	nil_literal,
+	true_literal,
+	false_literal,
+	builtin: []const coral.io.Byte,
+	number_literal: []const coral.io.Byte,
+	string_literal: []const coral.io.Byte,
+	symbol_literal: []const coral.io.Byte,
+	table_literal: TableLiteral,
+	grouped_expression: *Expression,
+	local_get: []const coral.io.Byte,
+	local_set: []const coral.io.Byte,
+
+	field_get: struct {
+		object_expression: *Expression,
+		identifier: []const coral.io.Byte,
+	},
+
+	field_set: struct {
+		object_expression: *Expression,
+		identifier: []const coral.io.Byte,
+		value_expression: *Expression,
+	},
+
+	subscript_get: struct {
+		object_expression: *Expression,
+		subscript_expression: *Expression,
+	},
+
+	subscript_set: struct {
+		object_expression: *Expression,
+		subscript_expression: *Expression,
+		value_expression: *Expression,
+	},
+
+	binary_operation: struct {
+		operator: BinaryOperator,
+		lhs_expression: *Expression,
+		rhs_expression: *Expression,
+	},
+
+	unary_operation: struct {
+		operator: UnaryOperator,
+		expression: *Expression,
+	},
+
+	invoke: struct {
+		object_expression: *Expression,
+		argument_expressions: List,
+	},
+
+	pub const BinaryOperator = enum {
+		addition,
+		subtraction,
+		multiplication,
+		divsion,
+		equals_comparison,
+		greater_than_comparison,
+		greater_equals_comparison,
+		less_than_comparison,
+		less_equals_comparison,
+
+		fn token(self: BinaryOperator) tokens.Token {
+			return switch (self) {
+				.addition => .symbol_plus,
+				.subtraction => .symbol_minus,
+				.multiplication => .symbol_asterisk,
+				.divsion => .symbol_forward_slash,
+				.equals_comparison => .symbol_double_equals,
+				.greater_than_comparison => .symbol_greater_than,
+				.greater_equals_comparison => .symbol_greater_equals,
+				.less_than_comparison => .symbol_less_than,
+				.less_equals_comparison => .symbol_less_equals,
+			};
+		}
+	};
+
+	pub const TableLiteral = coral.list.Stack(struct {
+		key_expression: Expression,
+		value_expression: Expression,
+	});
+
+	pub const List = coral.list.Stack(Expression);
+};
+
+const ExpressionParser = fn (self: *Self) ParseError!Expression;
+
+pub const ParseError = error {
+	OutOfMemory,
+	BadSyntax,
+};
+
+const Self = @This();
+
+pub const Statement = union (enum) {
+	@"return": struct {
+		expression: ?Expression,
+	},
+
+	expression: Expression,
+
+	const List = coral.list.Stack(Statement);
+};
+
+const UnaryOperator = enum {
+	boolean_negation,
+	numeric_negation,
+};
+
+fn binary_operation_parser(
+	comptime parse_next: ExpressionParser,
+	comptime operators: []const Expression.BinaryOperator) ExpressionParser {
+
+	const BinaryOperationParser = struct {
+		fn parse(self: *Self) ParseError!Expression {
+			const allocator = self.arena.as_allocator();
+			var expression = try parse_next(self);
+
+			inline for (operators) |operator| {
+				const token = comptime operator.token();
+
+				if (self.tokenizer.token == coral.io.tag_of(token)) {
+					self.tokenizer.step();
+
+					if (self.tokenizer.token == .end) {
+						return self.report("expected other half of expression after `" ++ comptime token.text() ++ "`");
+					}
+
+					expression = .{
+						.binary_operation = .{
+							.operator = operator,
+							.lhs_expression = try coral.io.allocate_one(allocator, expression),
+							.rhs_expression = try coral.io.allocate_one(allocator, try parse_next(self)),
+						},
+					};
+				}
+			}
+
+			return expression;
+		}
+	};
+
+	return BinaryOperationParser.parse;
+}
+
+pub fn error_message(self: Self) []const coral.io.Byte {
+	return self.error_buffer.values;
+}
+
+pub fn free(self: *Self) void {
+	self.arena.free();
+	self.statements.free();
+	self.error_buffer.free();
+}
+
+pub fn make(allocator: coral.io.Allocator, ast_name: []const coral.io.Byte) Self {
+	return Self{
+		.arena = coral.arena.Stacking.make(allocator, 4096),
+		.error_buffer = coral.list.ByteStack.make(allocator),
+		.statements = Statement.List.make(allocator),
+		.tokenizer = .{.source = ""},
+		.allocator = allocator,
+		.name = ast_name,
+	};
+}
+
+fn report(self: *Self, message: []const coral.io.Byte) ParseError {
+	coral.utf8.print_formatted(coral.list.stack_as_writer(&self.error_buffer), "{name}@{line}: {message}", .{
+		.name = self.name,
+		.line = self.tokenizer.lines_stepped,
+		.message = message,
+	}) catch return error.OutOfMemory;
+
+	return error.BadSyntax;
+}
+
+pub fn list_statements(self: Self) []const Statement {
+	return self.statements.values;
+}
+
+pub fn parse(self: *Self, data: []const coral.io.Byte) ParseError!void {
+	self.tokenizer = .{.source = data};
+
+	var has_returned = false;
+
+	self.tokenizer.skip_newlines();
+
+	while (true) {
+		try self.statements.push_one(parse_statement: {
+			switch (self.tokenizer.token) {
+				.end => return,
+
+				.keyword_return => {
+					if (has_returned) {
+						return self.report("multiple returns in function scope but expected only one");
+					}
+
+					self.tokenizer.step();
+
+					if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
+						break: parse_statement .{
+							.@"return" = .{
+								.expression = try self.parse_expression(),
+							},
+						};
+					}
+
+					if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
+						return self.report("expected end or newline after return statement");
+					}
+
+					has_returned = true;
+
+					break: parse_statement .{
+						.@"return" = .{
+							.expression = null,
+						},
+					};
+				},
+
+				else => {
+					break: parse_statement .{
+						.expression = try self.parse_expression()
+					};
+				},
+			}
+		});
+	}
+}
+
+const parse_additive = binary_operation_parser(parse_equality, &.{
+	.addition,
+	.subtraction,
+});
+
+const parse_comparison = binary_operation_parser(parse_term, &.{
+	.greater_than_comparison,
+	.greater_equals_comparison,
+	.less_than_comparison,
+	.less_equals_comparison
+});
+
+const parse_equality = binary_operation_parser(parse_comparison, &.{
+	.equals_comparison,
+});
+
+pub fn parse_expression(self: *Self) ParseError!Expression {
+	const allocator = self.arena.as_allocator();
+	const expression = try parse_additive(self);
+
+	if (self.tokenizer.token == .symbol_equals) {
+		self.tokenizer.skip_newlines();
+
+		if (self.tokenizer.token == .end) {
+			return self.report("expected assignment after `=`");
+		}
+
+		return switch (expression) {
+			.local_get => |local_get| .{.local_set = local_get},
+
+			.field_get => |field_get| .{
+				.field_set = .{
+					.object_expression = field_get.object_expression,
+					.identifier = field_get.identifier,
+					.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
+				},
+			},
+
+			.subscript_get => |subscript_get| .{
+				.subscript_set = .{
+					.object_expression = subscript_get.object_expression,
+					.subscript_expression = subscript_get.subscript_expression,
+					.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
+				},
+			},
+
+			else => self.report("expected local or field on left-hand side of expression"),
+		};
+	}
+
+	return expression;
+}
+
+fn parse_factor(self: *Self) ParseError!Expression {
+	const allocator = self.arena.as_allocator();
+
+	var expression = @as(Expression, parse: {
+		switch (self.tokenizer.token) {
+			.symbol_paren_left => {
+				self.tokenizer.skip_newlines();
+
+				if (self.tokenizer.token == .end) {
+					return self.report("expected an expression after `(`");
+				}
+
+				const expression = try self.parse_expression();
+
+				if (self.tokenizer.token != .symbol_paren_right) {
+					return self.report("expected a closing `)` after expression");
+				}
+
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.grouped_expression = try coral.io.allocate_one(allocator, expression)};
+			},
+
+			.keyword_nil => {
+				self.tokenizer.skip_newlines();
+
+				break: parse .nil_literal;
+			},
+
+			.keyword_true => {
+				self.tokenizer.skip_newlines();
+
+				break: parse .true_literal;
+			},
+
+			.keyword_false => {
+				self.tokenizer.skip_newlines();
+
+				break: parse .false_literal;
+			},
+
+			.number => |value| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.number_literal = value};
+			},
+
+			.string => |value| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.string_literal = value};
+			},
+
+			.identifier => |identifier| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.local_get = identifier};
+			},
+
+			.builtin => |builtin| {
+				self.tokenizer.skip_newlines();
+
+				break: parse .{.builtin = builtin};
+			},
+
+			.symbol_brace_left => {
+				var table_literal = Expression.TableLiteral.make(allocator);
+
+				self.tokenizer.skip_newlines();
+
+				while (true) {
+					switch (self.tokenizer.token) {
+						.symbol_brace_right => {
+							self.tokenizer.skip_newlines();
+
+							break: parse .{.table_literal = table_literal};
+						},
+
+						.symbol_period => {
+							self.tokenizer.step();
+
+							const identifier = switch (self.tokenizer.token) {
+								.identifier => |identifier| identifier,
+								else => return self.report("expected identifier after `.`"),
+							};
+
+							self.tokenizer.skip_newlines();
+
+							if (self.tokenizer.token != .symbol_equals) {
+								return self.report("expected `=` after symbol");
+							}
+
+							self.tokenizer.skip_newlines();
+
+							try table_literal.push_one(.{
+								.value_expression = try self.parse_expression(),
+								.key_expression = .{.symbol_literal = identifier},
+							});
+
+							switch (self.tokenizer.token) {
+								.symbol_comma => self.tokenizer.skip_newlines(),
+
+								.symbol_brace_right => {
+									self.tokenizer.skip_newlines();
+
+									break: parse .{.table_literal = table_literal};
+								},
+
+								else => return self.report("expected `,` or `}` after expression"),
+							}
+						},
+
+						.symbol_bracket_left => {
+							self.tokenizer.step();
+
+							const subscript_expression = try self.parse_expression();
+
+							if (self.tokenizer.token != .symbol_bracket_right) {
+								return self.report("expected `]` after subscript expression");
+							}
+
+							self.tokenizer.skip_newlines();
+
+							if (self.tokenizer.token != .symbol_equals) {
+								return self.report("expected `=` after `]`");
+							}
+
+							self.tokenizer.skip_newlines();
+
+							try table_literal.push_one(.{
+								.value_expression = try self.parse_expression(),
+								.key_expression = subscript_expression,
+							});
+
+							switch (self.tokenizer.token) {
+								.symbol_comma => self.tokenizer.skip_newlines(),
+
+								.symbol_brace_right => {
+									self.tokenizer.skip_newlines();
+
+									break: parse .{.table_literal = table_literal};
+								},
+
+								else => return self.report("expected `,` or `}` after expression"),
+							}
+						},
+
+						else => return self.report("expected `}` or fields in table literal"),
+					}
+				}
+			},
+
+			.symbol_minus => {
+				self.tokenizer.skip_newlines();
+
+				if (self.tokenizer.token == .end) {
+					return self.report("expected expression after numeric negation (`-`)");
+				}
+
+				break: parse .{
+					.unary_operation = .{
+						.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
+						.operator = .numeric_negation,
+					},
+				};
+			},
+
+			.symbol_bang => {
+				self.tokenizer.skip_newlines();
+
+				if (self.tokenizer.token == .end) {
+					return self.report("expected expression after boolean negation (`!`)");
+				}
+
+				break: parse .{
+					.unary_operation = .{
+						.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
+						.operator = .boolean_negation,
+					},
+				};
+			},
+
+			else => return self.report("unexpected token in expression"),
+		}
+	});
+
+	while (true) {
+		switch (self.tokenizer.token) {
+			.symbol_period => {
+				self.tokenizer.skip_newlines();
+
+				// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
+				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
+
+				expression = .{
+					.field_get = .{
+						.identifier = switch (self.tokenizer.token) {
+							.identifier => |field_identifier| field_identifier,
+							else => return self.report("expected identifier after `.`"),
+						},
+
+						.object_expression = unnecessary_temp,
+					},
+				};
+
+				self.tokenizer.skip_newlines();
+			},
+
+			.symbol_bracket_left => {
+				self.tokenizer.skip_newlines();
+
+				// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
+				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
+
+				expression = .{
+					.subscript_get = .{
+						.subscript_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
+						.object_expression = unnecessary_temp,
+					},
+				};
+
+				if (self.tokenizer.token != .symbol_bracket_right) {
+					return self.report("expected `]` subscript expression");
+				}
+
+				self.tokenizer.skip_newlines();
+			},
+
+			.symbol_paren_left => {
+				var argument_expressions = Expression.List.make(allocator);
+
+				while (true) {
+					self.tokenizer.skip_newlines();
+
+					switch (self.tokenizer.token) {
+						.symbol_paren_right => break,
+
+						else => {
+							try argument_expressions.push_one(try self.parse_expression());
+
+							switch (self.tokenizer.token) {
+								.symbol_comma => continue,
+								.symbol_paren_right => break,
+								else => return self.report("expected `,` or `)` after function argument expression"),
+							}
+						},
+					}
+				}
+
+				self.tokenizer.skip_newlines();
+
+				// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
+				const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
+
+				expression = .{
+					.invoke = .{
+						.argument_expressions = argument_expressions,
+						.object_expression = unnecessary_temp,
+					},
+				};
+			},
+
+			else => break,
+		}
+	}
+
+	return expression;
+}
+
+const parse_term = binary_operation_parser(parse_factor, &.{
+	.multiplication,
+	.divsion,
+});

source/ona/kym/ast.zig

@@ -1,677 +0,0 @@
-const coral = @import("coral");
-
-const tokens = @import("./tokens.zig");
-
-pub const BinaryOperator = enum {
-	addition,
-	subtraction,
-	multiplication,
-	divsion,
-	equals_comparison,
-	greater_than_comparison,
-	greater_equals_comparison,
-	less_than_comparison,
-	less_equals_comparison,
-
-	fn builder(comptime build_next: ExpressionBuilder, comptime operators: []const BinaryOperator) ExpressionBuilder {
-		const Builder = struct {
-			fn build(self: *Tree) ParseError!Expression {
-				const allocator = self.arena.as_allocator();
-				var expression = try build_next(self);
-
-				inline for (operators) |operator| {
-					const token = @as(tokens.Token, switch (operator) {
-						.addition => .symbol_plus,
-						.subtraction => .symbol_minus,
-						.multiplication => .symbol_asterisk,
-						.divsion => .symbol_forward_slash,
-						.equals_comparison => .symbol_double_equals,
-						.greater_than_comparison => .symbol_greater_than,
-						.greater_equals_comparison => .symbol_greater_equals,
-						.less_than_comparison => .symbol_less_than,
-						.less_equals_comparison => .symbol_less_equals,
-					});
-
-					if (self.tokenizer.token == coral.io.tag_of(token)) {
-						self.tokenizer.step();
-
-						if (self.tokenizer.token == .end) {
-							return self.report(
-								"expected other half of expression after `" ++
-								comptime token.text() ++
-								"`");
-						}
-
-						// TODO: Remove once Zig has fixed struct self-reassignment.
-						const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
-
-						expression = .{
-							.binary_operation = .{
-								.operator = operator,
-								.lhs_expression = unnecessary_temp,
-								.rhs_expression = try coral.io.allocate_one(allocator, try build_next(self)),
-							},
-						};
-					}
-				}
-
-				return expression;
-			}
-		};
-
-		return Builder.build;
-	}
-};
-
-pub const Expression = union (enum) {
-	nil_literal,
-	true_literal,
-	false_literal,
-	builtin: []const coral.io.Byte,
-	number_literal: []const coral.io.Byte,
-	string_literal: []const coral.io.Byte,
-	symbol_literal: []const coral.io.Byte,
-	table_literal: TableLiteral,
-	grouped_expression: *Expression,
-
-	local_get: struct {
-		identifier: []const coral.io.Byte,
-	},
-
-	local_set: struct {
-		identifier: []const coral.io.Byte,
-		value_expression: *Expression,
-	},
-
-	field_get: struct {
-		object_expression: *Expression,
-		identifier: []const coral.io.Byte,
-	},
-
-	field_set: struct {
-		object_expression: *Expression,
-		identifier: []const coral.io.Byte,
-		value_expression: *Expression,
-	},
-
-	subscript_get: struct {
-		object_expression: *Expression,
-		subscript_expression: *Expression,
-	},
-
-	subscript_set: struct {
-		object_expression: *Expression,
-		subscript_expression: *Expression,
-		value_expression: *Expression,
-	},
-
-	binary_operation: struct {
-		operator: BinaryOperator,
-		lhs_expression: *Expression,
-		rhs_expression: *Expression,
-	},
-
-	unary_operation: struct {
-		operator: UnaryOperator,
-		expression: *Expression,
-	},
-
-	invoke: struct {
-		object_expression: *Expression,
-		argument_expressions: List,
-	},
-
-	const List = coral.list.Stack(Expression);
-
-	const TableLiteral = coral.list.Stack(struct {
-		key_expression: Expression,
-		value_expression: Expression,
-	});
-};
-
-const ExpressionBuilder = fn (self: *Tree) ParseError!Expression;
-
-pub const ParseError = error {
-	OutOfMemory,
-	BadSyntax,
-};
-
-pub const Statement = union (enum) {
-	@"return": ?Expression,
-
-	@"if": struct {
-		condition_expression: Expression,
-		block_statements: List,
-		else_statement: ?*Statement,
-	},
-
-	@"while": struct {
-		condition_expression: Expression,
-		block_statements: List,
-	},
-
-	block: List,
-	expression: Expression,
-
-	const List = coral.list.Stack(Statement);
-};
-
-pub const Tree = struct {
-	name: []const coral.io.Byte,
-	allocator: coral.io.Allocator,
-	arena: coral.arena.Stacking,
-	error_buffer: coral.list.ByteStack,
-	tokenizer: tokens.Tokenizer,
-	parsed_statements: Statement.List,
-	has_returned: bool,
-
-	pub fn error_message(self: Tree) []const coral.io.Byte {
-		return self.error_buffer.values;
-	}
-
-	pub fn free(self: *Tree) void {
-		self.parsed_statements.free();
-		self.error_buffer.free();
-		self.arena.free();
-	}
-
-	pub fn make(allocator: coral.io.Allocator, ast_name: []const coral.io.Byte) Tree {
-		return .{
-			.arena = coral.arena.Stacking.make(allocator, 4096),
-			.error_buffer = coral.list.ByteStack.make(allocator),
-			.parsed_statements = Statement.List.make(allocator),
-			.tokenizer = .{.source = ""},
-			.allocator = allocator,
-			.name = ast_name,
-			.has_returned = false,
-		};
-	}
-
-	pub fn parse(self: *Tree, data: []const coral.io.Byte) ParseError![]const Statement {
-		self.free();
-
-		self.tokenizer = .{.source = data};
-		self.has_returned = false;
-
-		self.tokenizer.skip_newlines();
-
-		while (self.tokenizer.token != .end) {
-			try self.parsed_statements.push_one(try self.parse_statement());
-		}
-
-		return self.parsed_statements.values;
-	}
-
-	const parse_additive = BinaryOperator.builder(parse_equality, &.{
-		.addition,
-		.subtraction,
-	});
-
-	fn parse_branch(self: *Tree) ParseError!Statement {
-		const allocator = self.arena.as_allocator();
-
-		defer self.tokenizer.skip_newlines();
-
-		self.tokenizer.step();
-
-		const condition_expression = try self.parse_expression();
-
-		if (self.tokenizer.token != .symbol_colon) {
-			return self.report("expected `:` after `if` statement condition");
-		}
-
-		var statements = Statement.List.make(allocator);
-
-		self.tokenizer.skip_newlines();
-
-		while (true) {
-			switch (self.tokenizer.token) {
-				.keyword_end => {
-					return .{
-						.@"if" = .{
-							.condition_expression = condition_expression,
-							.block_statements = statements,
-							.else_statement = null,
-						},
-					};
-				},
-
-				.keyword_else => {
-					self.tokenizer.step();
-
-					if (self.tokenizer.token != .symbol_colon) {
-						return self.report("expected `:` after `if` statement condition");
-					}
-
-					var else_statements = Statement.List.make(allocator);
-
-					self.tokenizer.skip_newlines();
-
-					while (self.tokenizer.token != .keyword_end) {
-						try else_statements.push_one(try self.parse_statement());
-					}
-
-					return .{
-						.@"if" = .{
-							.else_statement = try coral.io.allocate_one(allocator, Statement{.block = else_statements}),
-							.condition_expression = condition_expression,
-							.block_statements = statements,
-						},
-					};
-				},
-
-				.keyword_elif => {
-					return .{
-						.@"if" = .{
-							.else_statement = try coral.io.allocate_one(allocator, try self.parse_branch()),
-							.condition_expression = condition_expression,
-							.block_statements = statements,
-						},
-					};
-				},
-
-				else => try statements.push_one(try self.parse_statement()),
-			}
-		}
-	}
-
-	const parse_comparison = BinaryOperator.builder(parse_term, &.{
-		.greater_than_comparison,
-		.greater_equals_comparison,
-		.less_than_comparison,
-		.less_equals_comparison
-	});
-
-	const parse_equality = BinaryOperator.builder(parse_comparison, &.{
-		.equals_comparison,
-	});
-
-	pub fn parse_expression(self: *Tree) ParseError!Expression {
-		const allocator = self.arena.as_allocator();
-		const expression = try self.parse_additive();
-
-		if (self.tokenizer.token == .symbol_equals) {
-			self.tokenizer.skip_newlines();
-
-			if (self.tokenizer.token == .end) {
-				return self.report("expected assignment after `=`");
-			}
-
-			return switch (expression) {
-				.local_get => |local_get| .{
-					.local_set = .{
-						.identifier = local_get.identifier,
-						.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
-					},
-				},
-
-				.field_get => |field_get| .{
-					.field_set = .{
-						.object_expression = field_get.object_expression,
-						.identifier = field_get.identifier,
-						.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
-					},
-				},
-
-				.subscript_get => |subscript_get| .{
-					.subscript_set = .{
-						.object_expression = subscript_get.object_expression,
-						.subscript_expression = subscript_get.subscript_expression,
-						.value_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
-					},
-				},
-
-				else => self.report("expected local or field on left-hand side of expression"),
-			};
-		}
-
-		return expression;
-	}
-
-	fn parse_factor(self: *Tree) ParseError!Expression {
-		const allocator = self.arena.as_allocator();
-
-		var expression = @as(Expression, parse: {
-			switch (self.tokenizer.token) {
-				.symbol_paren_left => {
-					self.tokenizer.skip_newlines();
-
-					if (self.tokenizer.token == .end) {
-						return self.report("expected an expression after `(`");
-					}
-
-					const expression = try self.parse_expression();
-
-					if (self.tokenizer.token != .symbol_paren_right) {
-						return self.report("expected a closing `)` after expression");
-					}
-
-					self.tokenizer.skip_newlines();
-
-					break: parse .{.grouped_expression = try coral.io.allocate_one(allocator, expression)};
-				},
-
-				.keyword_nil => {
-					self.tokenizer.skip_newlines();
-
-					break: parse .nil_literal;
-				},
-
-				.keyword_true => {
-					self.tokenizer.skip_newlines();
-
-					break: parse .true_literal;
-				},
-
-				.keyword_false => {
-					self.tokenizer.skip_newlines();
-
-					break: parse .false_literal;
-				},
-
-				.number => |value| {
-					self.tokenizer.skip_newlines();
-
-					break: parse .{.number_literal = value};
-				},
-
-				.string => |value| {
-					self.tokenizer.skip_newlines();
-
-					break: parse .{.string_literal = value};
-				},
-
-				.identifier => |identifier| {
-					self.tokenizer.skip_newlines();
-
-					break: parse .{.local_get = .{.identifier = identifier}};
-				},
-
-				.builtin => |builtin| {
-					self.tokenizer.skip_newlines();
-
-					break: parse .{.builtin = builtin};
-				},
-
-				.symbol_brace_left => {
-					var table_literal = Expression.TableLiteral.make(allocator);
-
-					self.tokenizer.skip_newlines();
-
-					while (true) {
-						switch (self.tokenizer.token) {
-							.symbol_brace_right => {
-								self.tokenizer.skip_newlines();
-
-								break: parse .{.table_literal = table_literal};
-							},
-
-							.symbol_period => {
-								self.tokenizer.step();
-
-								const identifier = switch (self.tokenizer.token) {
-									.identifier => |identifier| identifier,
-									else => return self.report("expected identifier after `.`"),
-								};
-
-								self.tokenizer.skip_newlines();
-
-								if (self.tokenizer.token != .symbol_equals) {
-									return self.report("expected `=` after symbol");
-								}
-
-								self.tokenizer.skip_newlines();
-
-								try table_literal.push_one(.{
-									.value_expression = try self.parse_expression(),
-									.key_expression = .{.symbol_literal = identifier},
-								});
-
-								switch (self.tokenizer.token) {
-									.symbol_comma => self.tokenizer.skip_newlines(),
-
-									.symbol_brace_right => {
-										self.tokenizer.skip_newlines();
-
-										break: parse .{.table_literal = table_literal};
-									},
-
-									else => return self.report("expected `,` or `}` after expression"),
-								}
-							},
-
-							.symbol_bracket_left => {
-								self.tokenizer.step();
-
-								const subscript_expression = try self.parse_expression();
-
-								if (self.tokenizer.token != .symbol_bracket_right) {
-									return self.report("expected `]` after subscript expression");
-								}
-
-								self.tokenizer.skip_newlines();
-
-								if (self.tokenizer.token != .symbol_equals) {
-									return self.report("expected `=` after `]`");
-								}
-
-								self.tokenizer.skip_newlines();
-
-								try table_literal.push_one(.{
-									.value_expression = try self.parse_expression(),
-									.key_expression = subscript_expression,
-								});
-
-								switch (self.tokenizer.token) {
-									.symbol_comma => self.tokenizer.skip_newlines(),
-
-									.symbol_brace_right => {
-										self.tokenizer.skip_newlines();
-
-										break: parse .{.table_literal = table_literal};
-									},
-
-									else => return self.report("expected `,` or `}` after expression"),
-								}
-							},
-
-							else => return self.report("expected `}` or fields in table literal"),
-						}
-					}
-				},
-
-				.symbol_minus => {
-					self.tokenizer.skip_newlines();
-
-					if (self.tokenizer.token == .end) {
-						return self.report("expected expression after numeric negation (`-`)");
-					}
-
-					break: parse .{
-						.unary_operation = .{
-							.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
-							.operator = .numeric_negation,
-						},
-					};
-				},
-
-				.symbol_bang => {
-					self.tokenizer.skip_newlines();
-
-					if (self.tokenizer.token == .end) {
-						return self.report("expected expression after boolean negation (`!`)");
-					}
-
-					break: parse .{
-						.unary_operation = .{
-							.expression = try coral.io.allocate_one(allocator, try self.parse_factor()),
-							.operator = .boolean_negation,
-						},
-					};
-				},
-
-				else => return self.report("unexpected token in expression"),
-			}
-		});
-
-		while (true) {
-			switch (self.tokenizer.token) {
-				.symbol_period => {
-					self.tokenizer.skip_newlines();
-
-					// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
-					const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
-
-					expression = .{
-						.field_get = .{
-							.identifier = switch (self.tokenizer.token) {
-								.identifier => |field_identifier| field_identifier,
-								else => return self.report("expected identifier after `.`"),
-							},
-
-							.object_expression = unnecessary_temp,
-						},
-					};
-
-					self.tokenizer.skip_newlines();
-				},
-
-				.symbol_bracket_left => {
-					self.tokenizer.skip_newlines();
-
-					// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
-					const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
-
-					expression = .{
-						.subscript_get = .{
-							.subscript_expression = try coral.io.allocate_one(allocator, try self.parse_expression()),
-							.object_expression = unnecessary_temp,
-						},
-					};
-
-					if (self.tokenizer.token != .symbol_bracket_right) {
-						return self.report("expected `]` subscript expression");
-					}
-
-					self.tokenizer.skip_newlines();
-				},
-
-				.symbol_paren_left => {
-					var argument_expressions = Expression.List.make(allocator);
-
-					while (true) {
-						self.tokenizer.skip_newlines();
-
-						switch (self.tokenizer.token) {
-							.symbol_paren_right => break,
-
-							else => {
-								try argument_expressions.push_one(try self.parse_expression());
-
-								switch (self.tokenizer.token) {
-									.symbol_comma => continue,
-									.symbol_paren_right => break,
-									else => return self.report("expected `,` or `)` after function argument expression"),
-								}
-							},
-						}
-					}
-
-					self.tokenizer.skip_newlines();
-
-					// TODO: Remove when Zig fixes miscompilation with in-place struct re-assignment.
-					const unnecessary_temp = try coral.io.allocate_one(allocator, expression);
-
-					expression = .{
-						.invoke = .{
-							.argument_expressions = argument_expressions,
-							.object_expression = unnecessary_temp,
-						},
-					};
-				},
-
-				else => break,
-			}
-		}
-
-		return expression;
-	}
-
-	fn parse_statement(self: *Tree) ParseError!Statement {
-		const allocator = self.arena.as_allocator();
-
-		switch (self.tokenizer.token) {
-			.keyword_return => {
-				defer self.tokenizer.skip_newlines();
-
-				if (self.has_returned) {
-					return self.report("multiple returns in lambda scope but expected only one");
-				}
-
-				self.tokenizer.step();
-
-				if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
-					return .{.@"return" = try self.parse_expression()};
-				}
-
-				if (self.tokenizer.token != .end and self.tokenizer.token != .newline) {
-					return self.report("expected end or newline after return statement");
-				}
-
-				self.has_returned = true;
-
-				return .{.@"return" = null};
-			},
-
-			.keyword_while => {
-				defer self.tokenizer.skip_newlines();
-
-				self.tokenizer.step();
-
-				const condition_expression = try self.parse_expression();
-
-				if (self.tokenizer.token != .symbol_colon) {
-					return self.report("expected `:` after `while` statement");
-				}
-
-				var statements = Statement.List.make(allocator);
-
-				self.tokenizer.skip_newlines();
-
-				while (self.tokenizer.token != .keyword_end) {
-					try statements.push_one(try self.parse_statement());
-				}
-
-				return .{
-					.@"while" = .{
-						.block_statements = statements,
-						.condition_expression = condition_expression,
-					},
-				};
-			},
-
-			.keyword_if => return self.parse_branch(),
-			else => return .{.expression = try self.parse_expression()},
-		}
-	}
-
-	const parse_term = BinaryOperator.builder(parse_factor, &.{
-		.multiplication,
-		.divsion,
-	});
-
-	fn report(self: *Tree, message: []const coral.io.Byte) ParseError {
-		coral.utf8.print_formatted(coral.list.stack_as_writer(&self.error_buffer), "{name}@{line}: {message}", .{
-			.name = self.name,
-			.line = self.tokenizer.lines_stepped,
-			.message = message,
-		}) catch return error.OutOfMemory;
-
-		return error.BadSyntax;
-	}
-};
-
-pub const UnaryOperator = enum {
-	boolean_negation,
-	numeric_negation,
-};

source/ona/kym/tokens.zig

@@ -21,7 +21,7 @@ pub const Token = union(enum) {
 	symbol_bracket_left,
 	symbol_bracket_right,
 	symbol_period,
-	symbol_colon,
+	symbol_lambda,
 	symbol_less_than,
 	symbol_less_equals,
 	symbol_greater_than,
@@ -38,12 +38,6 @@ pub const Token = union(enum) {
 	keyword_return,
 	keyword_self,
 	keyword_const,
-	keyword_if,
-	keyword_do,
-	keyword_end,
-	keyword_while,
-	keyword_else,
-	keyword_elif,
 
 	pub fn text(self: Token) []const coral.io.Byte {
 		return switch (self) {
@@ -68,7 +62,7 @@ pub const Token = union(enum) {
 			.symbol_bracket_left => "[",
 			.symbol_bracket_right => "]",
 			.symbol_period => ".",
-			.symbol_colon => ":",
+			.symbol_lambda => "=>",
 			.symbol_less_than => "<",
 			.symbol_less_equals => "<=",
 			.symbol_greater_than => ">",
@@ -85,12 +79,6 @@ pub const Token = union(enum) {
 			.keyword_true => "true",
 			.keyword_return => "return",
 			.keyword_self => "self",
-			.keyword_if => "if",
-			.keyword_do => "do",
-			.keyword_end => "end",
-			.keyword_while => "while",
-			.keyword_elif => "elif",
-			.keyword_else => "else",
 		};
 	}
 };
@@ -98,7 +86,7 @@ pub const Token = union(enum) {
 pub const Tokenizer = struct {
 	source: []const coral.io.Byte,
 	lines_stepped: usize = 1,
-	token: Token = .newline,
+	token: Token = .end,
 
 	pub fn skip_newlines(self: *Tokenizer) void {
 		self.step();
@@ -185,29 +173,9 @@ pub const Tokenizer = struct {
 							}
 						},
 
-						'd' => {
+						'n' => {
-							if (coral.io.ends_with(identifier, "o")) {
+							if (coral.io.ends_with(identifier, "il")) {
-								self.token = .keyword_do;
+								self.token = .keyword_nil;
-
-								return;
-							}
-						},
-
-						'e' => {
-							if (coral.io.ends_with(identifier, "lse")) {
-								self.token = .keyword_else;
-
-								return;
-							}
-
-							if (coral.io.ends_with(identifier, "lif")) {
-								self.token = .keyword_elif;
-
-								return;
-							}
-
-							if (coral.io.ends_with(identifier, "nd")) {
-								self.token = .keyword_end;
 
 								return;
 							}
@@ -221,17 +189,9 @@ pub const Tokenizer = struct {
 							}
 						},
 
-						'i' => {
+						't' => {
-							if (coral.io.ends_with(identifier, "f")) {
+							if (coral.io.ends_with(identifier, "rue")) {
-								self.token = .keyword_if;
+								self.token = .keyword_true;
-
-								return;
-							}
-						},
-
-						'n' => {
-							if (coral.io.ends_with(identifier, "il")) {
-								self.token = .keyword_nil;
 
 								return;
 							}
@@ -253,22 +213,6 @@ pub const Tokenizer = struct {
 							}
 						},
 
-						't' => {
-							if (coral.io.ends_with(identifier, "rue")) {
-								self.token = .keyword_true;
-
-								return;
-							}
-						},
-
-						'w' => {
-							if (coral.io.ends_with(identifier, "hile")) {
-								self.token = .keyword_while;
-
-								return;
-							}
-						},
-
 						else => {},
 					}
 
@@ -394,13 +338,6 @@ pub const Tokenizer = struct {
 					return;
 				},
 
-				':' => {
-					self.token = .symbol_colon;
-					cursor += 1;
-
-					return;
-				},
-
 				'=' => {
 					cursor += 1;
 
@@ -413,6 +350,13 @@ pub const Tokenizer = struct {
 								return;
 							},
 
+							'>' => {
+								cursor += 1;
+								self.token = .symbol_lambda;
+
+								return;
+							},
+
 							else => {},
 						}
 					}