Add tests

Cargo.toml

@@ -5,5 +5,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-error-chain = { version = "0.12.4", default-features = false }
+anyhow = "1.0"
+thiserror = "1.0"
 lazy_static = "1.5.0"
+
+[dev-dependencies]
+glob = "0.3.1"

src/callable.rs

@@ -16,8 +16,7 @@ impl Callable for Value {
                         "Wrong number of arguments: Expected {}, got {}",
                         arity,
                         args.len()
-                    ))
-                    .into())
+                    )))
                 } else {
                     func(args)
                 }

src/errors.rs

@@ -1,23 +1,16 @@
-#![allow(unknown_lints)]
-
 use crate::scanner::Token;
+use thiserror::Error;
 
-error_chain! {
-    errors {
-        ScanError(line: usize, t: String) {
-            description("Invalid syntax")
-            display("Error at line {}: {}", line, t)
-        }
-        ParseError(tok: Token, t: String) {
-            description("Invalid program")
-            display("Error at line {} at '{}': {}", tok.line, tok.lexeme, t)
-        }
-        EvaluateError(t: String) {
-            description("Invalid expression")
-            display("Error: {}", t)
-        }
-    }
-    foreign_links {
-        IO(::std::io::Error);
-    }
+#[derive(Error, Debug)]
+pub enum ErrorKind {
+    #[error("Error at line {0}: {1}")]
+    ScanError(usize, String),
+    #[error("Error at line {} at '{}': {t}", tok.line, tok.lexeme)]
+    ParseError { tok: Token, t: String },
+    #[error("Error: {0}")]
+    EvaluateError(String),
+    #[error("IO Error: {0}")]
+    IO(#[from] ::std::io::Error),
 }
+
+pub type Result<T> = std::result::Result<T, ErrorKind>;

src/interpreter.rs

@@ -2,10 +2,9 @@ use std::fmt;
 use std::fs::File;
 use std::path::Path;
 
-use std::io::Result;
 use std::io::{self, BufRead, Read, Write};
 
-use std::process;
+use anyhow::Result;
 
 use std::collections::HashMap;
 
@@ -16,80 +15,50 @@ use crate::parser::Parser;
 use crate::scanner::Scanner;
 
 pub struct Interpreter {
-    had_error: bool,
     env: Environment,
 }
 
 impl Interpreter {
     pub fn new() -> Interpreter {
         let mut env = Environment::new();
         env.insert("clock", Value::BuiltinFunc("clock".to_string(), 0, clock));
-        Interpreter {
-            had_error: false,
-            env,
-        }
+        Interpreter { env }
     }
 
-    pub fn run_prompt(&mut self) -> Result<()> {
+    pub fn run_prompt(&mut self) -> io::Result<()> {
         let stdin = io::stdin();
         print!("> ");
         io::stdout().flush()?;
         for line in stdin.lock().lines() {
-            self.run(&line.unwrap(), true);
-            self.had_error = false;
+            match self.run(&line.unwrap()) {
+                Ok(v) => println!("{v}"),
+                Err(e) => eprintln!("{e}"),
+            }
             print!("> ");
             io::stdout().flush()?;
         }
         println!();
         Ok(())
     }
 
-    pub fn run_path<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
+    pub fn run_path<P: AsRef<Path>>(&mut self, path: P) -> Result<Value> {
         let mut s = String::new();
         let mut file = File::open(path)?;
         file.read_to_string(&mut s)?;
-        self.run(&s, false);
-        if self.had_error {
-            process::exit(65);
-        };
-        Ok(())
+        self.run(&s)
     }
 
-    fn run(&mut self, code: &str, print_value: bool) {
+    pub fn run(&mut self, code: &str) -> Result<Value> {
         let scanner = Scanner::new(code);
-        let stmts = match scanner
+        let stmts = scanner
             .scan_tokens()
-            .and_then(|tokens| Parser::new(tokens).parse())
-        {
-            Ok(x) => x,
-            Err(e) => {
-                self.error(e.to_string());
-                return;
-            }
-        };
+            .and_then(|tokens| Parser::new(tokens).parse())?;
 
+        let mut last_val = Value::Nil;
         for stmt in stmts {
-            if self.had_error {
-                break;
-            }
-            match stmt.interpret(&mut self.env) {
-                Ok(v) => {
-                    if print_value && Value::Nil != v {
-                        println!("{}", v);
-                    }
-                }
-                Err(e) => self.error(format!("{}", e)),
-            }
+            last_val = stmt.interpret(&mut self.env)?;
         }
-    }
-
-    fn error<S: AsRef<str>>(&mut self, message: S) {
-        self.report("", message.as_ref())
-    }
-
-    fn report<S: AsRef<str>>(&mut self, context: S, message: S) {
-        eprintln!("{}{}", context.as_ref(), message.as_ref());
-        self.had_error = true;
+        Ok(last_val)
     }
 }
 

src/main.rs

@@ -1,20 +1,22 @@
-#[macro_use] extern crate error_chain;
-#[macro_use] extern crate lazy_static;
-
+#[macro_use]
+extern crate lazy_static;
 use std::env;
 
 mod interpreter;
 use interpreter::Interpreter;
 
 mod errors;
 
-mod scanner;
-mod parser;
+#[cfg(test)]
+mod tests;
+
 mod ast;
 mod builtins;
-mod evaluable;
 mod callable;
+mod evaluable;
 mod interpretable;
+mod parser;
+mod scanner;
 
 fn main() {
     if env::args().len() > 2 {

src/parser.rs

@@ -207,11 +207,10 @@ impl Parser {
             let value = self.assignment()?;
             match expr {
                 Expr::Variable(id) => Ok(Expr::Assign(id, Box::new(value))),
-                x => Err(ErrorKind::ParseError(
-                    equals,
-                    format!("Invalid assignment target: {}", x),
-                )
-                .into()),
+                x => Err(ErrorKind::ParseError {
+                    tok: equals,
+                    t: format!("Invalid assignment target: {}", x),
+                }),
             }
         } else {
             Ok(expr)
@@ -349,9 +348,10 @@ impl Parser {
                 self.consume(TokenType::RightParen, "Expect ')' after expression")?;
                 Ok(Expr::Grouping(Box::new(Grouping { expr })))
             }
-            _ => Err(
-                ErrorKind::ParseError(self.peek().clone(), "Expect expression".to_string()).into(),
-            ),
+            _ => Err(ErrorKind::ParseError {
+                tok: self.peek().clone(),
+                t: "Expect expression".to_string(),
+            }),
         }
     }
 
@@ -383,7 +383,10 @@ impl Parser {
             self.advance();
             Ok(result)
         } else {
-            Err(ErrorKind::ParseError(self.peek().clone(), error.to_string()).into())
+            Err(ErrorKind::ParseError {
+                tok: self.peek().clone(),
+                t: error.to_string(),
+            })
         }
     }
 

src/scanner.rs

@@ -195,6 +195,7 @@ impl Scanner {
             if self.peek() == Some('\n') {
                 self.line += 1;
             }
+            self.advance();
         }
 
         if self.is_at_end() {

src/tests/loxfiles/assignment/associativity.lox

@@ -0,0 +1,9 @@
+var a = "a";
+var b = "b";
+var c = "c";
+
+// Assignment is right-associative.
+a = b = c;
+print a; // expect: c
+print b; // expect: c
+print c; // expect: c

src/tests/loxfiles/assignment/global.lox

@@ -0,0 +1,8 @@
+var a = "before";
+print a; // expect: before
+
+a = "after";
+print a; // expect: after
+
+print a = "arg"; // expect: arg
+print a; // expect: arg

src/tests/loxfiles/assignment/grouping.lox

@@ -0,0 +1,2 @@
+var a = "a";
+(a) = "value"; // Error at '=': Invalid assignment target.

src/tests/loxfiles/assignment/infix_operator.lox

@@ -0,0 +1,3 @@
+var a = "a";
+var b = "b";
+a + b = "value"; // Error at '=': Invalid assignment target.

src/tests/loxfiles/assignment/local.lox

@@ -0,0 +1,10 @@
+{
+  var a = "before";
+  print a; // expect: before
+
+  a = "after";
+  print a; // expect: after
+
+  print a = "arg"; // expect: arg
+  print a; // expect: arg
+}

src/tests/loxfiles/assignment/prefix_operator.lox

@@ -0,0 +1,2 @@
+var a = "a";
+!a = "value"; // Error at '=': Invalid assignment target.

src/tests/loxfiles/assignment/syntax.lox

@@ -0,0 +1,5 @@
+// Assignment on RHS of variable.
+var a = "before";
+var c = a = "var";
+print a; // expect: var
+print c; // expect: var

src/tests/loxfiles/assignment/to_this.lox

@@ -0,0 +1,7 @@
+class Foo {
+  Foo() {
+    this = "value"; // Error at '=': Invalid assignment target.
+  }
+}
+
+Foo();

src/tests/loxfiles/assignment/undefined.lox

@@ -0,0 +1 @@
+unknown = "what"; // expect runtime error: Undefined variable 'unknown'.