Chapter 11: Resolving and Binding (#8)

This implements [chapter 11](http://craftinginterpreters.com/resolving-and-binding.html) to resolve variables.

The resolver is probably a little odd for Rust and has two sources for bugs. For one the hash
map of the scopes uses the token instead of the expression for locals. If two tokens are on the
the same line this might be an issue. For another the `had_error` is still not implemented.

Author: jeschkies

README.md

@@ -12,3 +12,4 @@ Each commit corresponds to one chapter in the book:
   * [Chapter 7: Evaluating Expressions](https://github.com/jeschkies/lox-rs/commit/fd90ef985c88832c9af6f193e0614e41dd13ef28)
   * [Chapter 8: Statements and State](https://github.com/jeschkies/lox-rs/commit/941cbba900acb5876dbe6031b24ef31ff81ca99e)
   * [Chapter 9: Control Flow](https://github.com/jeschkies/lox-rs/commit/d1f8d67f65fa4d66e24e654fec7bd8d1529b124d)
+  * [Chapter 10: Functions](https://github.com/jeschkies/lox-rs/commit/0e10d13944a6cd77d37f9cdf393ed81ba9573172)

examples/inner_outer.lox

@@ -0,0 +1,10 @@
+var a = "global";
+{
+  fun showA() {
+    print a;
+  }
+
+  showA();
+  var a = "block";
+  showA();
+}

examples/scope.lox

@@ -17,4 +17,3 @@ var c = "global c";
 print a;
 print b;
 print c;
-

src/env.rs

@@ -31,6 +31,56 @@ impl Environment {
         self.values.insert(name, value);
     }
 
+    fn ancestor(&self, distance: usize) -> Rc<RefCell<Environment>> {
+        // Get first ancestor
+        let parent = self
+            .enclosing
+            .clone()
+            .expect(&format!("No enclosing environment at {}", 1));
+        let mut environment = Rc::clone(&parent);
+
+        // Get next ancestors
+        for i in 1..distance {
+            let parent = self
+                .enclosing
+                .clone()
+                .expect(&format!("No enclosing environment at {}", i));
+            environment = Rc::clone(&parent);
+        }
+        environment
+    }
+
+    pub fn get_at(&self, distance: usize, name: &Token) -> Result<Object, Error> {
+        let key = &*name.lexeme;
+        if distance > 0 {
+            Ok(self
+                .ancestor(distance)
+                .borrow()
+                .values
+                .get(key)
+                .expect(&format!("Undefined variable '{}'", key))
+                .clone())
+        } else {
+            Ok(self
+                .values
+                .get(key)
+                .expect(&format!("Undefined variable '{}'", key))
+                .clone())
+        }
+    }
+
+    pub fn assign_at(&mut self, distance: usize, name: &Token, value: Object) -> Result<(), Error> {
+        if distance > 0 {
+            self.ancestor(distance)
+                .borrow_mut()
+                .values
+                .insert(name.lexeme.clone(), value);
+        } else {
+            self.values.insert(name.lexeme.clone(), value);
+        }
+        Ok(())
+    }
+
     pub fn get(&self, name: &Token) -> Result<Object, Error> {
         let key = &*name.lexeme;
         if let Some(value) = self.values.get(key) {

src/function.rs

@@ -34,9 +34,13 @@ impl Function {
     ) -> Result<Object, Error> {
         match self {
             Function::Native { body, .. } => Ok(body(arguments)),
-            Function::User { params, body, closure, .. } => {
-                let mut environment =
-                    Rc::new(RefCell::new(Environment::from(closure)));
+            Function::User {
+                params,
+                body,
+                closure,
+                ..
+            } => {
+                let mut environment = Rc::new(RefCell::new(Environment::from(closure)));
                 for (param, argument) in params.iter().zip(arguments.iter()) {
                     environment
                         .borrow_mut()

src/interpreter.rs

@@ -7,12 +7,14 @@ use crate::syntax::{Expr, LiteralValue, Stmt};
 use crate::token::{Token, TokenType};
 
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::rc::Rc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub struct Interpreter {
     pub globals: Rc<RefCell<Environment>>,
     environment: Rc<RefCell<Environment>>,
+    locals: HashMap<Token, usize>, // This might break if two Tokens are on the same line and have the same name.
 }
 
 impl Interpreter {
@@ -33,6 +35,7 @@ impl Interpreter {
         Interpreter {
             globals: Rc::clone(&globals),
             environment: Rc::clone(&globals),
+            locals: HashMap::new(),
         }
     }
 
@@ -51,6 +54,10 @@ impl Interpreter {
         statement.accept(self)
     }
 
+    pub fn resolve(&mut self, name: &Token, depth: usize) {
+        self.locals.insert(name.clone(), depth);
+    }
+
     pub fn execute_block(
         &mut self,
         statements: &Vec<Stmt>,
@@ -98,6 +105,14 @@ impl Interpreter {
             message: "Operand must be a number.".to_string(),
         })
     }
+
+    fn look_up_variable(&self, name: &Token) -> Result<Object, Error> {
+        if let Some(distance) = self.locals.get(name) {
+            self.environment.borrow().get_at(*distance, name)
+        } else {
+            self.globals.borrow().get(name)
+        }
+    }
 }
 
 impl expr::Visitor<Object> for Interpreter {
@@ -254,12 +269,19 @@ impl expr::Visitor<Object> for Interpreter {
     }
 
     fn visit_variable_expr(&mut self, name: &Token) -> Result<Object, Error> {
-        self.environment.borrow().get(name)
+        self.look_up_variable(name)
     }
 
     fn visit_assign_expr(&mut self, name: &Token, value: &Expr) -> Result<Object, Error> {
         let v = self.evaluate(value)?;
-        self.environment.borrow_mut().assign(name, v.clone())?;
+
+        if let Some(distance) = self.locals.get(name) {
+            self.environment
+                .borrow_mut()
+                .assign_at(*distance, name, v.clone())?;
+        } else {
+            self.environment.borrow_mut().assign(name, v.clone())?;
+        }
         Ok(v)
     }
 }

src/main.rs

@@ -4,6 +4,7 @@ mod function;
 mod interpreter;
 mod object;
 mod parser;
+mod resolver;
 mod scanner;
 mod syntax;
 mod token;
@@ -15,6 +16,7 @@ use std::process::exit;
 use error::Error;
 use interpreter::Interpreter;
 use parser::Parser;
+use resolver::Resolver;
 use scanner::Scanner;
 use syntax::AstPrinter;
 
@@ -49,6 +51,12 @@ impl Lox {
 
         let mut parser = Parser::new(tokens);
         let statements = parser.parse()?;
+
+        let mut resolver = Resolver::new(&mut self.interpreter);
+        resolver.resolve_stmts(&statements);
+
+        // TODO: check if there was an error and return.
+
         self.interpreter.interpret(&statements)?;
         Ok(())
     }