Definition and reading of variables

src/ast/expr.rs

@@ -81,8 +81,14 @@ pub enum ExprType {
     Variable(Name),
 }
 
-#[derive(Debug)]
-pub struct Name(pub String);
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Name(String);
+
+impl Name {
+    pub fn new(s: String) -> Self {
+        Name(s)
+    }
+}
 
 impl Display for Name {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

src/ast/stmt.rs

@@ -36,7 +36,7 @@ impl Stmt {
         src: Arc<NamedSource<String>>,
     ) -> Self {
         Stmt {
-            stmt_type: StmtType::Var(Name(name), expr),
+            stmt_type: StmtType::Var(Name::new(name), expr),
             src,
             location,
         }

src/interpreter/environment.rs

@@ -11,4 +11,53 @@ impl Environment {
             values: HashMap::new(),
         }
     }
+
+    pub fn define(&mut self, key: Name, value: Value) {
+        self.values.insert(key, value);
+    }
+
+    pub fn get(&self, key: &Name) -> Option<Value> {
+        self.values.get(key).cloned()
+    }
+
+    pub fn assign(&mut self, key: Name, value: Value)-> Option<()> {
+        self.values.get_mut(&key).map(|old| *old = value)
+    }
 }
+
+#[cfg(test)]
+mod environment_tests {
+    use crate::{ast::expr::Name, value::Value};
+
+    use super::Environment;
+
+    #[test]
+    fn define_get() {
+        let mut env = Environment::new();
+        let name = Name::new("x".to_string());
+        env.define(name.clone(), Value::Boolean(true));
+        let returned = env.get(&name);
+        assert_eq!(returned, Some(Value::Boolean(true)))
+    }
+
+    #[test]
+    fn define_assign_get() {
+        let mut env = Environment::new();
+        let name = Name::new("x".to_string());
+        env.define(name.clone(), Value::Boolean(true));
+        let assigned = env.assign(name.clone(), Value::Boolean(false));
+        assert_eq!(assigned, Some(()));
+        let returned = env.get(&name);
+        assert_eq!(returned, Some(Value::Boolean(false)))
+    }
+
+    #[test]
+    fn assign_unasigned() {
+        let mut env = Environment::new();
+        let name = Name::new("x".to_string());
+        let assigned = env.assign(name.clone(), Value::Boolean(false));
+        assert_eq!(assigned, None);
+        let returned = env.get(&name);
+        assert_eq!(returned, None)
+    }
+}

src/interpreter/expression.rs

@@ -1,29 +1,35 @@
 use crate::{
-    ast::expr::{Expr, ExprType},
-    ast::token::{Token, TokenType},
+    ast::{
+        expr::{Expr, ExprType, Name},
+        token::{Token, TokenType},
+    },
     types::Type,
     value::Value,
 };
 
 use super::{literal::LiteralInterpreter, runtime_error::RuntimeError::*};
 use super::{Interpreter, Result};
-pub trait ExprInterpreter {
-    fn interpret_expr(&mut self, expr: &Expr) -> Result<Value>;
-}
 
-impl ExprInterpreter for Interpreter {
-    fn interpret_expr(&mut self, expr: &Expr) -> Result<Value> {
+impl Interpreter {
+    pub fn interpret_expr(&mut self, expr: &Expr) -> Result<Value> {
         match &expr.expr_type {
             ExprType::Binary(left, token, right) => self.interpret_binary(left, token, right),
             ExprType::Grouping(expr) => self.interpret_expr(expr),
             ExprType::Literal(l) => l.interpret(),
             ExprType::Unary(token, expr) => self.interpret_unary(token, expr),
-            ExprType::Variable(name) => todo!(),
+            ExprType::Variable(name) => self.read_variable(name, expr),
         }
     }
-}
 
-impl Interpreter {
+    fn read_variable(&self, name: &Name, expr: &Expr) -> Result<Value> {
+        let val = self.environment.get(name);
+        val.ok_or(UndefinedVariable {
+            name: name.clone(),
+            src: expr.src.clone(),
+            location: expr.location,
+        })
+    }
+
     fn is_truthy(value: Value) -> bool {
         match value {
             Value::Boolean(bool) => bool,
@@ -151,9 +157,11 @@ mod value_interpreter_tests {
         ast::{
             expr::{Expr, Literal},
             token::{Token, TokenType},
-        }, interpreter::{
-            expression::ExprInterpreter, runtime_error::RuntimeError::*, Interpreter,
-        }, printer::vec_printer::VecPrinter, types::Type, value::Value
+        },
+        interpreter::{runtime_error::RuntimeError::*, Interpreter},
+        printer::vec_printer::VecPrinter,
+        types::Type,
+        value::Value,
     };
 
     #[test]
@@ -174,21 +182,30 @@ mod value_interpreter_tests {
         let expr = literal(1.0.into());
         let expr = Expr::unary(token(TokenType::Bang), expr);
         let mut under_test = Interpreter::new(Box::new(VecPrinter::new()));
-        assert_matches!(under_test.interpret_expr(&expr).unwrap(), Value::Boolean(false));
+        assert_matches!(
+            under_test.interpret_expr(&expr).unwrap(),
+            Value::Boolean(false)
+        );
     }
     #[test]
     fn bang_false() {
         let expr = literal(Literal::Boolean(false));
         let expr = Expr::unary(token(TokenType::Bang), expr);
         let mut under_test = Interpreter::new(Box::new(VecPrinter::new()));
-        assert_matches!(under_test.interpret_expr(&expr).unwrap(), Value::Boolean(true));
+        assert_matches!(
+            under_test.interpret_expr(&expr).unwrap(),
+            Value::Boolean(true)
+        );
     }
     #[test]
     fn bang_nil() {
         let expr = literal(Literal::Nil);
         let expr = Expr::unary(token(TokenType::Bang), expr);
         let mut under_test = Interpreter::new(Box::new(VecPrinter::new()));
-        assert_matches!(under_test.interpret_expr(&expr).unwrap(), Value::Boolean(true));
+        assert_matches!(
+            under_test.interpret_expr(&expr).unwrap(),
+            Value::Boolean(true)
+        );
     }
     #[test]
     fn five_minus_one() {
@@ -222,7 +239,10 @@ mod value_interpreter_tests {
         let operator = token(TokenType::EqualEqual);
         let expr = Expr::binary(left, operator, right);
         let mut under_test = Interpreter::new(Box::new(VecPrinter::new()));
-        assert_matches!(under_test.interpret_expr(&expr).unwrap(), Value::Boolean(false));
+        assert_matches!(
+            under_test.interpret_expr(&expr).unwrap(),
+            Value::Boolean(false)
+        );
     }
     #[test]
     fn string_minus_one() {

src/interpreter/mod.rs

@@ -6,7 +6,7 @@ mod statement;
 
 use crate::{ast::stmt::Stmt, printer::Printer};
 
-use self::{environment::Environment, runtime_error::RuntimeError, statement::StmtInterpreter};
+use self::{environment::Environment, runtime_error::RuntimeError};
 
 type Result<T> = std::result::Result<T, RuntimeError>;
 pub struct Interpreter {

src/interpreter/runtime_error.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use miette::{Diagnostic, NamedSource, SourceSpan};
 
-use crate::types::Type;
+use crate::{ast::expr::Name, types::Type};
 
 #[derive(thiserror::Error, Debug, Diagnostic)]
 pub enum RuntimeError {
@@ -49,4 +49,13 @@ pub enum RuntimeError {
         #[label("{actual_rhs}")]
         rhs: SourceSpan,
     },
+
+    #[error("Undefined variable '{name}'")]
+    UndefinedVariable {
+        name: Name,
+        #[source_code]
+        src: Arc<NamedSource<String>>,
+        #[label("here")]
+        location: SourceSpan,
+    },
 }

src/interpreter/statement.rs

@@ -1,22 +1,23 @@
-use crate::ast::stmt::{Stmt, StmtType};
+use crate::{ast::{expr::{Expr, Name}, stmt::{Stmt, StmtType}}, value::Value};
 
-use super::expression::ExprInterpreter;
 use super::{Interpreter, Result};
 
-pub trait StmtInterpreter {
-    fn interpret_stmt(&mut self, statement: Stmt) -> Result<()>;
-}
-
-impl StmtInterpreter for Interpreter {
-    fn interpret_stmt(&mut self, statement: Stmt) -> Result<()> {
+impl Interpreter {
+    pub fn interpret_stmt(&mut self, statement: Stmt) -> Result<()> {
         match statement.stmt_type {
             StmtType::Expression(expr) => self.interpret_expr(&expr).map(|_| ()),
             StmtType::Print(expr) => self
                 .interpret_expr(&expr)
                 .map(|value| self.printer.print(value)),
-            StmtType::Var(_, _) => todo!(),
+            StmtType::Var(key, initializer) => self.define_var(key, initializer),
         }
     }
+
+    fn define_var(&mut self, key: Name, initializer: Option<Expr>) -> Result<()> {
+        let initializer = initializer.map_or(Ok(Value::Nil),|expr| self.interpret_expr(&expr))?;
+        self.environment.define(key, initializer);
+        Ok(())
+    }
 }
 #[cfg(test)]
 mod stmt_interpreter_tests {
@@ -25,11 +26,11 @@ mod stmt_interpreter_tests {
 
     use crate::{
         ast::{
-            expr::{Expr, Literal},
+            expr::{Expr, Literal, Name},
             stmt::Stmt,
             token::{Token, TokenType},
         },
-        interpreter::{statement::StmtInterpreter, Interpreter},
+        interpreter::Interpreter,
         printer::vec_printer::VecPrinter,
     };
 

src/lox.rs

@@ -63,4 +63,15 @@ mod lox_tests {
         lox.run_stdin(r#"print "string";"#.to_string()).unwrap();
         assert_eq!(printer.get_lines(), vec!["string".to_string().into()])
     }
+
+    #[test]
+    fn print_variable() {
+        let printer = VecPrinter::new();
+        let mut lox = Lox::new(Box::new(printer.clone()));
+        lox.run_stdin(r#"
+            var x = "string";
+            print "x=" + x;
+        "#.to_string()).unwrap();
+        assert_eq!(printer.get_lines(), vec!["x=string".to_string().into()])
+    }
 }