add 'error contexts' to parser error reports

examples/hello.ry

@@ -1,4 +1,4 @@
-import std;
+// import std;
 
 fn add(a: i32, b: i32) i32 {
     return a + b;

src/errors.zig

@@ -1,15 +1,24 @@
 const std = @import("std");
 
-pub fn report(line: usize, where: []const u8, message: []const u8) void {
+pub fn report(line: usize, where: []const u8, ctx_opt: ?[]const u8, message: []const u8) void {
+    if (ctx_opt) |ctx| {
+        std.debug.warn("[line {}] Error{} on {}: {}", line, where, ctx, message);
+    } else {
         std.debug.warn("[line {}] Error{}: {}", line, where, message);
     }
+}
 
 pub fn reportN(line: usize, message: []const u8) void {
     report(line, "", message);
 }
 
-pub fn reportFmt(line: usize, comptime fmt: []const u8, args: ...) void {
+pub fn reportFmt(line: usize, ctx_opt: ?[]const u8, comptime fmt: []const u8, args: ...) void {
+    if (ctx_opt) |ctx| {
+        std.debug.warn("[line {}] Error on {}", line, ctx);
+    } else {
         std.debug.warn("[line {}] Error", line);
+    }
+
     std.debug.warn(fmt, args);
     std.debug.warn("\n");
 }

src/main.zig

@@ -38,10 +38,12 @@ pub fn run(allocator: *std.mem.Allocator, slice: []const u8) !Result {
 
     var parser = parsers.Parser.init(allocator, &scan);
     var root = try parser.parse();
-    var it = root.Root.iterator();
+    if (root == null) {
+        return Result.ParseError;
+    }
 
     std.debug.warn("parse tree\n");
-    //printer.printNode(root, 0);
+    printer.printNode(root.?, 0);
 
     return Result.Ok;
 }

src/parsers.zig

@@ -3,7 +3,7 @@ const scanners = @import("scanners.zig");
 const main = @import("main.zig");
 const ast = @import("ast.zig");
 const tokens = @import("tokens.zig");
-const err = @import("errors.zig");
+const ereport = @import("errors.zig");
 const printer = @import("ast_printer.zig");
 
 const Allocator = std.mem.Allocator;
@@ -31,6 +31,7 @@ pub const Parser = struct {
     tokens: TokenList,
 
     hadError: bool = false,
+    err_ctx: ?[]const u8 = null,
 
     pub fn init(allocator: *Allocator, scanner: *Scanner) Parser {
         return Parser{
@@ -44,12 +45,47 @@ pub const Parser = struct {
         self.tokens.deinit();
     }
 
-    fn doError(self: *Parser, comptime fmt: []const u8, args: ...) void {
+    fn setErrContext(self: *Parser, comptime fmt: ?[]const u8, args: ...) void {
+        if (fmt == null) {
+            self.err_ctx = null;
+            return;
+        }
+
+        var buf = self.allocator.alloc(u8, 256) catch unreachable;
+        self.err_ctx = std.fmt.bufPrint(buf, fmt.?, args) catch unreachable;
+    }
+
+    fn doError(self: *Parser, comptime fmt: []const u8, args: ...) ParseError {
         self.hadError = true;
 
-        std.debug.warn("parser error at line {}\n\t", self.scanner.line);
+        std.debug.warn("parser error at line {}", self.scanner.line);
+        if (self.err_ctx) |ctx| {
+            std.debug.warn(" on {}", ctx);
+        }
+
+        std.debug.warn("\n\t");
+
         std.debug.warn(fmt, args);
         std.debug.warn("\n");
+
+        return ParseError.CompileError;
+    }
+
+    fn synchronize(self: *Parser) !void {
+        // TODO is it nextToken()?
+        _ = try self.nextToken();
+
+        while (!self.isAtEnd()) {
+            if (self.previous().typ == .Semicolon) return;
+
+            // TODO add more "stmt"-"starting" tokens here
+            switch (self.peek().typ) {
+                .Fn => return,
+                else => {},
+            }
+
+            _ = try self.nextToken();
+        }
     }
 
     fn peek(self: *Parser) Token {
@@ -60,11 +96,12 @@ pub const Parser = struct {
         return self.tokens.at(self.tokens.len - 2);
     }
 
-    fn tokenError(self: *Parser, token: Token, msg: []const u8) ParseError!void {
+    fn tokenError(self: *Parser, token: Token, msg: []const u8) ParseError {
+        std.debug.warn("ctx: '{}'\n", self.err_ctx);
         if (token.typ == .EOF) {
-            err.report(token.line, " at end", msg);
+            ereport.report(token.line, " at end", self.err_ctx, msg);
         } else {
-            err.reportFmt(token.line, " at '{}': {}", token.lexeme, msg);
+            ereport.reportFmt(token.line, self.err_ctx, " at '{}': {}", token.lexeme, msg);
         }
 
         return ParseError.CompileError;
@@ -104,8 +141,7 @@ pub const Parser = struct {
             return tok;
         }
 
-        try self.tokenError(self.peek(), msg);
-        return ParseError.CompileError;
+        return self.tokenError(self.peek(), msg);
     }
 
     /// Consume the current token. Gives default error messages
@@ -125,8 +161,7 @@ pub const Parser = struct {
             self.peek().typ,
         );
 
-        try self.tokenError(self.peek(), buf);
-        return ParseError.CompileError;
+        return self.tokenError(self.peek(), buf);
     }
 
     /// check() against multiple tokens
@@ -369,7 +404,7 @@ pub const Parser = struct {
         return expr;
     }
 
-    pub fn parse(self: *Parser) !*ast.Node {
+    pub fn parse(self: *Parser) !?*ast.Node {
         var root = try Node.mkRoot(self.allocator);
 
         var token_opt: ?Token = null;
@@ -384,7 +419,10 @@ pub const Parser = struct {
             var token = token_opt.?;
             if (token.typ == .EOF) break;
 
-            var node = try self.parseTopDecl();
+            var node = self.parseTopDecl() catch |err| {
+                if (err == ParseError.CompileError) return null;
+                return err;
+            };
             try root.Root.append(node.*);
         }
 
@@ -419,6 +457,8 @@ pub const Parser = struct {
 
         const name = try self.consumeSingle(.Identifier);
 
+        self.setErrContext("function {}", name.lexeme);
+
         _ = try self.consumeSingle(.LeftParen);
 
         while (self.peek().typ != .RightParen) {
@@ -603,6 +643,8 @@ pub const Parser = struct {
     }
 
     fn parseTopDecl(self: *@This()) !*Node {
+        self.setErrContext(null);
+
         return switch (self.peek().typ) {
             .Fn => try self.parseFnDecl(),
             .Const => try self.parseConstDecl(),
@@ -610,8 +652,7 @@ pub const Parser = struct {
             .Enum => try self.parseEnumDecl(),
 
             else => |typ| blk: {
-                self.doError("expected Fn, Const, Struct, got {}\n", typ);
-                return ParseError.CompileError;
+                return self.doError("expected Fn, Const, Struct, got {}\n", typ);
             },
         };
     }
@@ -840,8 +881,7 @@ pub const Parser = struct {
             .Get => |get| {
                 switch (op.typ) {
                     .ColonEqual => {
-                        self.doError("can not initialize struct field");
-                        return ParseError.CompileError;
+                        return self.doError("can not initialize struct field");
                     },
 
                     .Equal => return try self.mkSet(get.struc, get.name, value),
@@ -860,8 +900,7 @@ pub const Parser = struct {
             },
 
             else => |expr_typ| {
-                self.doError("Invalid assignment target {}", expr_typ);
-                return ParseError.CompileError;
+                return self.doError("Invalid assignment target {}", expr_typ);
             },
         }
     }
@@ -997,7 +1036,7 @@ pub const Parser = struct {
                     expr = try self.mkGet(expr, name);
                 }
             } else {
-                break;
+                return self.tokenError(self.peek(), "Expect expression.");
             }
         }
 
@@ -1031,8 +1070,7 @@ pub const Parser = struct {
         // <expr>{a: 10 b: 10}
         // for this to work properly, <expr> must be Variable, since its a type.
         if (ast.ExprType(expr.*) != .Variable) {
-            self.doError("Expected variable for struct type, got {}", ast.ExprType(expr.*));
-            return ParseError.CompileError;
+            return self.doError("Expected variable for struct type, got {}", ast.ExprType(expr.*));
         }
 
         var inits = ast.StructInitList.init(self.allocator);
@@ -1096,8 +1134,7 @@ pub const Parser = struct {
             },
 
             else => blk: {
-                self.doError("expected literal, got {}", curtype);
-                return ParseError.CompileError;
+                return self.doError("expected literal, got {}", curtype);
             },
         };