Work on improving parser errors.

lox-compiler/src/bettercompiler/statements.rs

@@ -41,6 +41,7 @@ fn compile_stmt(compiler: &mut Compiler, stmt: &WithSpan<Stmt>) {
             compile_class(compiler, identifier.as_ref(), extends.as_ref(), stmts)
         }
         Stmt::Import(path, identifiers) => compile_import(compiler, path, identifiers.as_ref()),
+        Stmt::Error => (),
     }
 }
 

lox-syntax/src/ast.rs

@@ -45,6 +45,7 @@ pub enum Expr {
     Call(Box<WithSpan<Expr>>, Vec<WithSpan<Expr>>),
     Get(Box<WithSpan<Expr>>, WithSpan<Identifier>),
     Set(Box<WithSpan<Expr>>, WithSpan<Identifier>, Box<WithSpan<Expr>>),
+    Error,
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -63,6 +64,7 @@ pub enum Stmt {
         Vec<WithSpan<Stmt>>,
     ),
     Import(WithSpan<String>, Option<Vec<WithSpan<String>>>),
+    Error,
 }
 
 pub type Ast = Vec<WithSpan<Stmt>>;

lox-syntax/src/expr_parser.rs

@@ -71,7 +71,7 @@ fn parse_infix(it: &mut Parser, left: WithSpan<Expr>) -> Result<WithSpan<Expr>,
         TokenKind::Dot => parse_get(it, left),
         _ => {
             it.error(&format!("Unexpected {}", it.peek_token().value), it.peek_token().span);
-            Err(())
+            Ok(WithSpan::empty(Expr::Error))
         },
     }
 }
@@ -90,7 +90,7 @@ fn parse_prefix(it: &mut Parser) -> Result<WithSpan<Expr>, ()> {
         TokenKind::LeftParen => parse_grouping(it),
         _ => {
             it.error(&format!("Unexpected {}", it.peek_token().value), it.peek_token().span);
-            Err(())
+            Ok(WithSpan::empty(Expr::Error))
         },
     }
 }

lox-syntax/src/lib.rs

@@ -18,7 +18,11 @@ pub fn parse(code: &str) -> Result<Ast, Vec<Diagnostic>> {
     let tokens = tokenize_with_context(code);
     let mut parser = crate::parser::Parser::new(&tokens);
     match parse(&mut parser) {
-        Ok(ast) => Ok(ast),
+        Ok(ast) if parser.diagnostics().is_empty() => Ok(ast),
+        Ok(ast) => {
+            println!("Faulty AST: {:#?}", ast);
+            Err(parser.diagnostics().to_vec())
+        },
         Err(_) => Err(parser.diagnostics().to_vec()),
     }
 }

lox-syntax/src/parser.rs

@@ -65,6 +65,17 @@ impl<'a> Parser<'a> {
         }
     }
 
+    pub fn expect2(&mut self, expected: TokenKind) -> Option<Span> {
+        let token = self.peek_token();
+        let kind = TokenKind::from(token);
+        if kind != expected {
+            self.error(&format!("Expected {} got {}", expected, token.value), token.span);
+            return None;
+        }
+
+        Some(self.advance().span)
+    }
+
     pub fn optionally(&mut self, expected: TokenKind) -> Result<bool, ()> {
         let token = self.peek();
         if TokenKind::from(token) == expected {

lox-syntax/src/position.rs

@@ -32,6 +32,12 @@ impl Span {
     pub fn union_span(a: Self, b: Self) -> Self {
         use std::cmp;
 
+        if a == Span::empty() {
+            return b;
+        } else if b == Span::empty() {
+            return a;
+        }
+
         Span {
             start: cmp::min(a.start, b.start),
             end: cmp::max(a.end, b.end),

lox-syntax/src/stmt_parser.rs

@@ -181,9 +181,14 @@ fn parse_return_statement(it: &mut Parser) -> Result<WithSpan<Stmt>, ()> {
 
 fn parse_expr_statement(it: &mut Parser) -> Result<WithSpan<Stmt>, ()> {
     let expr = parse_expr(it)?;
-    let end_span = it.expect(TokenKind::Semicolon)?;
+    let end_span = match it.expect2(TokenKind::Semicolon) {
+        Some(token) => token,
+        None => {
+            return Ok(WithSpan::empty(Stmt::Error));
+        },
+    };
 
-    let span = Span::union(&expr, end_span);
+    let span = Span::union_span(expr.span, end_span);
     Ok(WithSpan::new(Stmt::Expression(Box::new(expr)), span))
 }
 

test.lox

@@ -1,9 +1,3 @@
-{fun fib(n) {
-  if (n < 2) return n;
-  return fib(n - 2) + fib(n - 1);
-}
-
-var start = clock();
-print fib(35) == 9227465;
-print clock() - start;
-}
+// 3 +*4;
+// 3*;
+print (3-);