vig/src/parser.zig

1105 lines
31 KiB
Zig

const std = @import("std");
const scanners = @import("scanner.zig");
const main = @import("main.zig");
const ast = @import("ast.zig");
const tokens = @import("tokens.zig");
const err = @import("errors.zig");
const printer = @import("ast_printer.zig");
const Allocator = std.mem.Allocator;
const Scanner = scanners.Scanner;
const Token = tokens.Token;
const TokenType = tokens.TokenType;
const Result = main.Result;
const Node = ast.Node;
const Expr = ast.Expr;
const Stmt = ast.Stmt;
const TokenList = std.ArrayList(Token);
const FieldState = struct {
public: bool = false,
mutable: bool = false,
mutable_outside: bool = false,
};
pub const Parser = struct {
allocator: *Allocator,
scanner: *Scanner,
tokens: TokenList,
hadError: bool = false,
pub fn init(allocator: *Allocator, scanner: *Scanner) Parser {
return Parser{
.allocator = allocator,
.scanner = scanner,
.tokens = TokenList.init(allocator),
};
}
pub fn deinit(self: *@This()) void {
self.tokens.deinit();
}
fn doError(self: *Parser, comptime fmt: []const u8, args: anytype) void {
self.hadError = true;
std.debug.warn("parser error at line {}\n\t", .{self.scanner.line});
std.debug.warn(fmt, args);
std.debug.warn("\n", .{});
}
fn peek(self: *Parser) Token {
return self.tokens.items[self.tokens.items.len - 1];
}
fn previous(self: *Parser) Token {
return self.tokens.items[self.tokens.items.len - 2];
}
fn tokenError(self: *Parser, token: Token, msg: []const u8) Result!void {
if (token.ttype == .EOF) {
err.report(token.line, " at end", msg);
} else {
err.reportFmt(token.line, " at '{}': {}", .{ token.lexeme, msg });
}
return Result.CompileError;
}
fn isAtEnd(self: *Parser) bool {
return self.peek().ttype == .EOF;
}
fn check(self: *Parser, ttype: TokenType) bool {
if (self.isAtEnd()) return false;
return self.peek().ttype == ttype;
}
fn nextToken(self: *Parser) !Token {
var token: Token = undefined;
while (true) {
var next_token_opt = try self.scanner.nextToken();
if (next_token_opt) |token_nice| {
token = token_nice;
break;
}
}
try self.tokens.append(token);
std.debug.warn("skip to {}\n", .{token});
return token;
}
/// Consume the current token type, then walk to the next token.
/// Returns the consumed token.
fn consume(self: *Parser, ttype: TokenType, comptime msg: []const u8) !Token {
if (self.check(ttype)) {
var tok = self.peek();
_ = try self.nextToken();
return tok;
}
try self.tokenError(self.peek(), msg);
return Result.CompileError;
}
/// Consume the current token. Gives default error messages
fn consumeSingle(self: *Parser, ttype: TokenType) !Token {
if (self.check(ttype)) {
var cur = self.peek();
_ = try self.nextToken();
return cur;
}
// TODO maybe this could be entirely comptime?
var buf_main: [1000]u8 = undefined;
var buf = try std.fmt.bufPrint(buf_main[0..], "expected {}, got {}", .{
ttype,
self.peek().ttype,
});
try self.tokenError(self.peek(), buf);
return Result.CompileError;
}
/// check() against multiple tokens
fn compareAnyOf(self: *@This(), ttypes: []const TokenType) bool {
for (ttypes) |ttype| {
if (self.check(ttype)) return true;
}
return false;
}
// TODO maybe move helper functions to ast_helper.zig?
fn mkFnDecl(
self: *Parser,
name: Token,
params: ast.ParamList,
return_type: Token,
block: ast.StmtList,
method: ?*ast.MethodData,
) !*ast.Node {
var node = try self.allocator.create(Node);
node.* = Node{
.FnDecl = ast.FnDecl{
.func_name = name,
.params = params,
.return_type = return_type,
.body = block,
.method = method,
},
};
return node;
}
fn mkConstDecl(self: *Parser, consts: ast.ConstList) !*ast.Node {
var node = try self.allocator.create(Node);
node.* = Node{ .ConstDecl = consts };
return node;
}
fn mkBlock(self: *Parser, stmts: ast.StmtList) !*ast.Node {
var node = try self.allocator.create(Node);
node.* = Node{ .Block = stmts };
return node;
}
fn mkStmt(self: *Parser, stmt: *Stmt) !*ast.Node {
var node = try self.allocator.create(Node);
node.* = Node{ .Stmt = stmt };
return node;
}
fn mkStmtExpr(self: *Parser, expr: *Expr) !*Stmt {
var stmt = try self.allocator.create(Stmt);
stmt.* = Stmt{ .Expr = expr };
return stmt;
}
fn mkGrouping(self: *Parser, expr: *Expr) !*ast.Expr {
var grouping = try self.allocator.create(Expr);
grouping.* = Expr{ .Grouping = expr };
return grouping;
}
fn mkUnary(self: *Parser, op: Token, right: *Expr) !*Expr {
std.debug.warn("Unary\n", .{});
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Unary = ast.UnaryExpr{
.op = op,
.right = right,
},
};
return expr;
}
fn mkBinary(self: *Parser, left: *Expr, op: Token, right: *Expr) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Binary = ast.BinaryExpr{
.left = left,
.op = op,
.right = right,
},
};
return expr;
}
fn mkLogical(self: *Parser, left: *Expr, op: Token, right: *Expr) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Logical = ast.LogicalExpr{
.left = left,
.op = op,
.right = right,
},
};
return expr;
}
fn mkAssign(self: *Parser, name: Token, value: *Expr) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Assign = ast.AssignExpr{
.name = name,
.value = value,
},
};
return expr;
}
fn mkVarDecl(self: *@This(), name: Token, value: *Expr, mutable: bool) !*Expr {
var vardecl = try self.allocator.create(Expr);
vardecl.* = Expr{
.VarDecl = ast.VarDecl{
.assign = ast.AssignExpr{
.name = name,
.value = value,
},
.mutable = mutable,
},
};
return vardecl;
}
fn mkCall(self: *@This(), callee: *Expr, paren: Token, args: ast.ExprList) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Call = ast.CallExpr{
.callee = callee,
.paren = paren,
.arguments = args,
},
};
return expr;
}
fn mkStructExpr(self: *@This(), name: Token, args: ast.StructInitList) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Struct = ast.StructExpr{
.name = name,
.inits = args,
},
};
return expr;
}
fn mkGet(self: *@This(), struc: *Expr, name: Token) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Get = ast.GetExpr{
.struc = struc,
.name = name,
},
};
return expr;
}
fn mkSet(self: *@This(), struc: *Expr, field: Token, value: *Expr) !*Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Set = ast.SetExpr{
.struc = struc,
.field = field,
.value = value,
},
};
return expr;
}
fn mkBool(self: *Parser, val: bool) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Literal = ast.LiteralExpr{
.Bool = val,
},
};
return expr;
}
fn mkInteger(self: *Parser, val: []const u8) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Literal = ast.LiteralExpr{
.Integer = val,
},
};
return expr;
}
fn mkFloat(self: *Parser, val: []const u8) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Literal = ast.LiteralExpr{
.Float = val,
},
};
return expr;
}
fn mkString(self: *Parser, val: []const u8) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Literal = ast.LiteralExpr{
.String = val,
},
};
return expr;
}
fn mkArray(self: *Parser, exprs: ast.ExprList) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{
.Literal = ast.LiteralExpr{
.Array = exprs,
},
};
return expr;
}
fn mkVariable(self: *Parser, variable: Token) !*ast.Expr {
var expr = try self.allocator.create(Expr);
expr.* = Expr{ .Variable = variable };
return expr;
}
pub fn parse(self: *Parser) !*ast.Node {
var root = try Node.mkRoot(self.allocator);
var token_opt: ?Token = null;
while (true) {
if (token_opt == null) {
token_opt = try self.nextToken();
} else {
token_opt = self.peek();
}
var token = token_opt.?;
if (token.ttype == .EOF) break;
var node = try self.parseTopDecl();
try root.Root.append(node);
}
if (self.hadError) {
return error.ParseError;
}
return root;
}
/// Copy a token with a different lexeme.
fn mkToken(self: *@This(), ttype: TokenType, lexeme: []const u8, line: usize) !Token {
const owned_lexeme = try std.mem.dupe(self.allocator, u8, lexeme);
return Token{
.ttype = ttype,
.lexeme = owned_lexeme,
.line = line,
};
}
fn parseFnDecl(self: *@This()) !*Node {
var param_list = ast.ParamList.init(self.allocator);
errdefer param_list.deinit();
var method: ?*ast.MethodData = null;
_ = try self.consumeSingle(.Fn);
if (self.check(.LeftParen)) {
method = try self.parsePreMethod();
}
const name = try self.consumeSingle(.Identifier);
_ = try self.consumeSingle(.LeftParen);
while (self.peek().ttype != .RightParen) {
const param_name = try self.consumeSingle(.Identifier);
const param_type = try self.consumeSingle(.Identifier);
try param_list.append(ast.ParamDecl{
.name = param_name,
.typ = param_type,
});
}
_ = try self.consumeSingle(.RightParen);
// the return type is default void if a type
// is not provided
var return_type: Token = undefined;
if (self.check(.Identifier)) {
return_type = try self.consumeSingle(.Identifier);
} else {
return_type = try self.mkToken(.Identifier, "void", name.line);
}
var block_node = try self.parseBlock();
return try self.mkFnDecl(name, param_list, return_type, block_node.Block, method);
}
/// parse the (v [mut] T) part of the method (defined here
/// as a premethod)
fn parsePreMethod(self: *@This()) !?*ast.MethodData {
_ = try self.consumeSingle(.LeftParen);
var mutable_ref: bool = false;
const variable = try self.consumeSingle(.Identifier);
if (self.check(.Mut)) {
_ = try self.consumeSingle(.Mut);
mutable_ref = true;
}
const typ = try self.consumeSingle(.Identifier);
_ = try self.consumeSingle(.RightParen);
// create method data and assign the values we got into it
var method = try self.allocator.create(ast.MethodData);
method.* = ast.MethodData{
.variable = variable,
.typ = typ,
.mutable = mutable_ref,
};
return method;
}
fn parseConstDecl(self: *@This()) !*Node {
var consts = ast.ConstList.init(self.allocator);
errdefer consts.deinit();
_ = try self.consumeSingle(.Const);
_ = try self.consumeSingle(.LeftParen);
while (self.peek().ttype != .RightParen) {
const const_name = try self.consumeSingle(.Identifier);
_ = try self.consumeSingle(.Equal);
// const declarations dont have type, a future type system must
// check the output type of the expression and assign it to the
// const later on.
var expr = try self.parseExpr();
try consts.append(ast.SingleConst{
.name = const_name,
.expr = expr,
});
}
_ = try self.consumeSingle(.RightParen);
return self.mkConstDecl(consts);
}
fn parseStructDecl(self: *@This()) !*Node {
var fields = ast.FieldList.init(self.allocator);
errdefer fields.deinit();
_ = try self.consumeSingle(.Struct);
var name = try self.consumeSingle(.Identifier);
_ = try self.consumeSingle(.LeftBrace);
var field_state = FieldState{};
while (!self.check(.RightBrace)) {
try self.parseFieldModifiers(&field_state);
const field_name = try self.consumeSingle(.Identifier);
const field_type = try self.consumeSingle(.Identifier);
// we could create a FieldState on the heap and copy our current
// field state into a StructField.state, but copying via this makes
// things so much nicer.
try fields.append(ast.StructField{
.name = field_name,
.typ = field_type,
.mutable = field_state.mutable,
.public = field_state.public,
.mutable_outside = field_state.mutable_outside,
});
}
_ = try self.consumeSingle(.RightBrace);
return Node.mkStructDecl(self.allocator, name, fields);
}
fn parseFieldModifiers(self: *@This(), field_state: *FieldState) !void {
// there are five access modifiers:
// - none (private immutable)
// - mut (private mutable)
// - pub (public immutable)
// - pub mut (public mutable only in module)
// - pub mut mut (public mutable everywhere)
// this function takes care of that by changing the current FieldState
// to what the modifiers dictate.
switch (self.peek().ttype) {
.Mut => {
// There are no oher modifiers that start with mut, so we
// can just go the way of marking it as mutable
_ = try self.consumeSingle(.Mut);
_ = try self.consumeSingle(.Colon);
field_state.mutable = true;
},
// 'pub', 'pub mut', and 'pub mut mut' are all handled here
.Pub => {
_ = try self.consumeSingle(.Pub);
field_state.public = true;
if (self.check(.Mut)) {
_ = try self.consumeSingle(.Mut);
field_state.mutable = true;
if (self.check(.Mut)) {
_ = try self.consumeSingle(.Mut);
field_state.mutable_outside = true;
}
}
_ = try self.consumeSingle(.Colon);
},
// if it isn't mut or pub we're likely in an identifier, just
// ignore it.
else => return,
}
}
fn parseEnumDecl(self: *@This()) !*Node {
_ = try self.consumeSingle(.Enum);
var fields = ast.TokenList.init(self.allocator);
errdefer fields.deinit();
const name = try self.consumeSingle(.Identifier);
_ = try self.consumeSingle(.LeftBrace);
while (!self.check(.RightBrace)) {
try fields.append(try self.consumeSingle(.Identifier));
}
_ = try self.consumeSingle(.RightBrace);
return try Node.mkEnumDecl(self.allocator, name, fields);
}
fn parseTopDecl(self: *@This()) !*Node {
return switch (self.peek().ttype) {
.Fn => try self.parseFnDecl(),
.Const => try self.parseConstDecl(),
.Struct => try self.parseStructDecl(),
.Enum => try self.parseEnumDecl(),
else => |ttype| blk: {
self.doError("expected Fn, Const, Struct, got {}\n", .{ttype});
return Result.CompileError;
},
};
}
fn parseBlockInternal(self: *@This(), comptime T: type) !T {
var stmts = T.init(self.allocator);
errdefer stmts.deinit();
_ = try self.consumeSingle(.LeftBrace);
while (self.peek().ttype != .RightBrace) {
var stmt = try self.parseStmt();
printer.printNode(try self.mkStmt(stmt), 0);
try stmts.append(stmt);
}
_ = try self.consumeSingle(.RightBrace);
return stmts;
}
fn parseStmt(self: *@This()) anyerror!*Stmt {
return switch (self.peek().ttype) {
.If => try self.parseIfStmt(),
.Loop => try self.parseLoop(),
.For => try self.parseForStmt(),
.Println => try self.parsePrintln(),
.Return => try self.parseReturn(),
else => try self.parseStmtExpr(),
};
}
/// Parse a list of statements.
fn parseBlock(self: *@This()) !*Node {
var stmts = try self.parseBlockInternal(ast.StmtList);
return try self.mkBlock(stmts);
}
/// parse blocks inside statements
fn parseStmtBlock(self: *@This()) !ast.Block {
var block = try self.parseBlockInternal(ast.Block);
return block;
}
fn parseIfStmt(self: *@This()) !*Stmt {
_ = try self.consumeSingle(.If);
var condition = try self.parseExpr();
const then_branch = try self.parseStmtBlock();
var else_branch: ?ast.Block = null;
if (self.check(.Else)) {
_ = try self.consumeSingle(.Else);
else_branch = try self.parseStmtBlock();
}
return try Stmt.mkIfStmt(
self.allocator,
condition,
then_branch,
else_branch,
);
}
fn parseForStmt(self: *@This()) !*Stmt {
// There are two types of for in vig's V subset:
// - for x in y
// - for idx, x in y
_ = try self.consumeSingle(.For);
var index_var: ?Token = null;
var value_var: Token = undefined;
const subject_1 = try self.consumeSingle(.Identifier);
if (self.check(.Comma)) {
_ = try self.consumeSingle(.Comma);
const subject_2 = try self.consumeSingle(.Identifier);
index_var = subject_1;
value_var = subject_2;
} else {
value_var = subject_1;
}
_ = try self.consumeSingle(.In);
// MUST be identifier
var array = try self.consumeSingle(.Identifier);
var block = try self.parseStmtBlock();
return try Stmt.mkFor(
self.allocator,
index_var,
value_var,
array,
block,
);
}
fn parseLoop(self: *@This()) !*Stmt {
_ = try self.consumeSingle(.Loop);
var expr: ?*Expr = null;
var body: ast.Block = undefined;
// 'loop {' = infinite loop
if (self.check(.LeftBrace)) {
body = try self.parseStmtBlock();
} else {
expr = try self.parseExpr();
body = try self.parseStmtBlock();
}
return try Stmt.mkLoop(self.allocator, expr, body);
}
fn parseReturn(self: *@This()) !*Stmt {
const tok = try self.consumeSingle(.Return);
const expr = try self.parseExpr();
return try Stmt.mkReturn(self.allocator, tok, expr);
}
fn parsePrintln(self: *@This()) !*Stmt {
_ = try self.consumeSingle(.Println);
_ = try self.consumeSingle(.LeftParen);
var expr = try self.parseExpr();
_ = try self.consumeSingle(.RightParen);
return try Stmt.mkPrintln(self.allocator, expr);
}
fn parseStmtExpr(self: *@This()) !*Stmt {
var expr = try self.parseExpr();
return try self.mkStmtExpr(expr);
}
fn parseExpr(self: *@This()) anyerror!*Expr {
return try self.parseAssignment();
}
fn parseAssignment(self: *@This()) anyerror!*Expr {
// there can be two assignments coming out of this function:
// - a mutable/immutable variable declaration with :=
// - an assignment to a variable with =, +=, -=
// one is a statement, other is an expression. since the normal result
// of this is an Expr, we wrap variable assignments in an Expr as well.
var mutable: bool = false;
if (self.check(.Mut)) {
_ = try self.consumeSingle(.Mut);
mutable = true;
}
var expr = try self.parseOr();
if (self.compareAnyOf(&[_]TokenType{
.ColonEqual, .Equal, .PlusEqual, .MinusEqual, .StarEqual,
.SlashEqual,
})) {
return try self.finishAssignment(expr, mutable);
}
return expr;
}
fn finishAssignment(self: *@This(), expr: *Expr, mutable: bool) !*Expr {
var op = self.peek();
_ = try self.nextToken();
var value = try self.parseAssignment();
// TODO convert binary's op field from Token to
// something else, maybe enum'd
const new_op_ttype: TokenType = switch (op.ttype) {
.ColonEqual => TokenType.ColonEqual,
.Equal => .Equal,
.PlusEqual => .Plus,
.MinusEqual => .Minus,
.StarEqual => .Star,
.SlashEqual => .Slash,
else => unreachable,
};
// we create new_lexeme so that
// the AST printer properly prints
// x += 1
// as
// (set x (+ x 1))
// and not
// (set x (+= x 1))
const new_lexeme: []const u8 = switch (op.ttype) {
.ColonEqual => ":=",
.Equal => "=",
.PlusEqual => "+",
.MinusEqual => "-",
.StarEqual => "*",
.SlashEqual => "/",
else => unreachable,
};
switch (expr.*) {
.Variable => {
switch (op.ttype) {
.ColonEqual => return try self.mkVarDecl(expr.Variable, value, mutable),
.Equal => return try self.mkAssign(expr.Variable, value),
.PlusEqual, .MinusEqual, .StarEqual, .SlashEqual => {
var new_op = try self.mkToken(new_op_ttype, new_lexeme, op.line);
return try self.mkAssign(
expr.Variable,
try self.mkBinary(expr, new_op, value),
);
},
else => unreachable,
}
},
.Get => |get| {
switch (op.ttype) {
.ColonEqual => {
self.doError("can not initialize struct field", .{});
return Result.CompileError;
},
.Equal => return try self.mkSet(get.struc, get.name, value),
.PlusEqual, .MinusEqual, .StarEqual, .SlashEqual => {
var new_op = try self.mkToken(new_op_ttype, new_lexeme, op.line);
return try self.mkSet(
get.struc,
get.name,
try self.mkBinary(expr, new_op, value),
);
},
else => unreachable,
}
},
else => |expr_typ| {
self.doError("Invalid assignment target {}", .{expr_typ});
return Result.CompileError;
},
}
}
fn parseOr(self: *@This()) !*Expr {
var expr = try self.parseAnd();
while (self.check(.Or)) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseAnd();
expr = try self.mkLogical(expr, op, right);
}
return expr;
}
fn parseAnd(self: *@This()) !*Expr {
var expr = try self.parseEquality();
while (self.check(.And)) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseEquality();
expr = try self.mkLogical(expr, op, right);
}
return expr;
}
fn parseEquality(self: *@This()) !*Expr {
var expr = try self.parseComparison();
while (self.check(.EqualEqual)) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseComparison();
expr = try self.mkBinary(expr, op, right);
}
return expr;
}
fn parseComparison(self: *@This()) !*Expr {
var expr = try self.parseAddition();
while (self.compareAnyOf(&[_]TokenType{
.Greater,
.GreaterEqual,
.Less,
.LessEqual,
})) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseAddition();
expr = try self.mkBinary(expr, op, right);
}
return expr;
}
fn parseAddition(self: *@This()) !*Expr {
var expr = try self.parseMultiplication();
while (self.compareAnyOf(&[_]TokenType{
.Minus, .Plus,
})) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseMultiplication();
expr = try self.mkBinary(expr, op, right);
}
return expr;
}
fn parseMultiplication(self: *@This()) !*Expr {
var expr = try self.parseUnary();
while (self.compareAnyOf(&[_]TokenType{
.Star, .Slash,
})) {
var op = self.peek();
_ = try self.nextToken();
var right = try self.parseUnary();
expr = try self.mkBinary(expr, op, right);
}
return expr;
}
fn parseUnary(self: *@This()) anyerror!*Expr {
if (self.compareAnyOf(&[_]TokenType{ .Bang, .Minus })) {
var op = self.previous();
var right = try self.parseUnary();
return try self.mkUnary(op, right);
}
var expr = try self.parseCall();
return expr;
}
/// Parse either:
/// - A function call
/// - A struct initialization (Point.{...})
/// - A struct Get expression (p.x)
fn parseCall(self: *@This()) !*Expr {
var expr = try self.parsePrimary();
while (true) {
if (self.check(.LeftParen)) {
_ = try self.consumeSingle(.LeftParen);
expr = try self.finishCall(expr);
} else if (self.check(.Dot)) {
_ = try self.consumeSingle(.Dot);
if (self.check(.LeftBrace)) {
_ = try self.consumeSingle(.LeftBrace);
expr = try self.finishStructVal(expr);
} else {
var name = try self.consume(
.Identifier,
"Expect property name after '.'",
);
expr = try self.mkGet(expr, name);
}
} else {
break;
}
}
return expr;
}
fn finishCall(self: *@This(), callee: *Expr) !*Expr {
var args = ast.ExprList.init(self.allocator);
errdefer args.deinit();
if (!self.check(.RightParen)) {
// emulating do-while really badly
var arg = try self.parseExpr();
try args.append(arg);
while (self.check(.Comma)) {
_ = try self.consumeSingle(.Comma);
arg = try self.parseExpr();
try args.append(arg);
}
}
var paren = try self.consume(.RightParen, "Expected ')' after arguments");
return self.mkCall(callee, paren, args);
}
fn finishStructVal(self: *@This(), expr: *Expr) !*Expr {
// <expr>{a: 10 b: 10}
// for this to work properly, <expr> must be Variable, since its a type.
if (@as(ast.ExprType, expr.*) != .Variable) {
self.doError("Expected variable for struct type, got {}", .{@as(ast.ExprType, expr.*)});
return Result.CompileError;
}
var inits = ast.StructInitList.init(self.allocator);
errdefer inits.deinit();
while (!self.check(.RightBrace)) {
const field_name = try self.consumeSingle(.Identifier);
// TODO check .Comma for the quick initialization {val,val,val}
_ = try self.consumeSingle(.Colon);
const field_value = try self.parseExpr();
try inits.append(ast.StructInit{
.field = field_name,
.expr = field_value,
});
}
_ = try self.consumeSingle(.RightBrace);
return try self.mkStructExpr(expr.Variable, inits);
}
fn parsePrimary(self: *@This()) !*Expr {
const curtype = self.peek().ttype;
const lexeme = self.peek().lexeme;
var expr = switch (curtype) {
.False => try self.mkBool(false),
.True => try self.mkBool(true),
.Integer => try self.mkInteger(lexeme),
.Float => try self.mkFloat(lexeme),
.String => try self.mkString(lexeme),
.Identifier => try self.mkVariable(self.peek()),
// type checking for arrays happens at later stages
.LeftSquare => {
_ = try self.consumeSingle(.LeftSquare);
var exprs = ast.ExprList.init(self.allocator);
errdefer exprs.deinit();
while (!self.check(.RightSquare)) {
try exprs.append(try self.parseExpr());
if (self.check(.Comma)) _ = try self.consumeSingle(.Comma);
}
_ = try self.consumeSingle(.RightSquare);
return try self.mkArray(exprs);
},
.LeftParen => {
_ = try self.nextToken();
var expr = try self.parseExpr();
_ = try self.consume(.RightParen, "Expected ')' after expression");
// for groupings, we don't want to skip tokens as we already
// consumed RightParen.
return try self.mkGrouping(expr);
},
else => blk: {
self.doError("expected literal, got {}", .{curtype});
return Result.CompileError;
},
};
_ = try self.nextToken();
return expr;
}
};