feat: var resolution (#13)

* fix: unified definition for functions

anonymous and named functions follow the same code path now

* fix: remove extra clone

* wip: resolvers

* wip: variable resolution pass

* feat: initial resolver pass

* feat: some semblance of working resolver

* wip: working out the assignment bug via api

* fix: logging for statements

* feat: working resolution full

* fix: tests

Author: maxArturo

Cargo.lock

@@ -12,7 +12,6 @@ type Link<T> = Option<Rc<Scope<T>>>;
 pub struct Scope<T> {
     values: RefCell<HashMap<String, T>>,
     pub parent: Link<T>,
-    pub globals: Link<T>,
 }
 
 impl<T: Display> Scope<T> {
@@ -45,37 +44,20 @@ impl<T: Display + Clone> Scope<T> {
         Self {
             values: RefCell::new(HashMap::default()),
             parent: None,
-            globals: Self::new_globals(),
         }
     }
 
-    fn new_globals() -> Link<T> {
-        Some(Rc::new(Self {
-            values: RefCell::new(HashMap::default()),
-            parent: None,
-            globals: None,
-        }))
-    }
-
     pub fn from_parent(parent: Rc<Scope<T>>) -> Rc<Scope<T>> {
-        let globals = parent.as_ref().globals.as_ref().map(Rc::clone);
         Rc::new(Self {
             values: RefCell::new(HashMap::new()),
             parent: Some(parent),
-            globals,
         })
     }
 
     pub fn define(&self, name: &str, val: T) {
         self.values.borrow_mut().insert(name.to_string(), val);
     }
 
-    pub fn define_global(&self, name: &str, val: T) {
-        if let Some(el) = self.globals.as_ref() {
-            el.define(name, val)
-        }
-    }
-
     pub fn assign(&self, name: &str, val: T) -> Result<()> {
         trace!("[assign] current env:\n{}", self);
         trace!(
@@ -95,28 +77,43 @@ impl<T: Display + Clone> Scope<T> {
         }
     }
 
+    pub fn assign_at(&self, distance: usize, name: &str, val: T) -> Result<()> {
+        self.ancestor(distance)?
+            .values
+            .borrow_mut()
+            .insert(name.to_owned(), val);
+        Ok(())
+    }
+
     pub fn get(&self, name: &str) -> Result<T> {
         trace!("[get] looking for: `{}` in:\n{}", name, self);
         self.values
             .borrow()
             .get(name)
             .cloned()
-            .or_else(|| {
-                trace!("[get] going into parent...");
-                self.parent
-                    .as_ref()
-                    .and_then(|parent| parent.as_ref().get(name).ok())
-            })
-            .or_else(|| {
-                trace!("[get] going into globals...");
-                self.globals
-                    .as_ref()
-                    .and_then(|globals| globals.get(name).ok())
-            })
             .ok_or(LoxErr::Undefined {
                 message: format!("variable undefined: {}", name),
             })
     }
+
+    pub fn get_at(&self, distance: usize, name: &str) -> Result<T> {
+        self.ancestor(distance)?.get(name)
+    }
+
+    fn ancestor(&self, distance: usize) -> Result<&Scope<T>> {
+        let mut parent = self;
+
+        for _i in 0..distance {
+            parent = parent
+            .parent.as_ref()
+            .ok_or::<LoxErr>(LoxErr::Internal {
+                message: "Error with ancestor depth! Expected to find some ancestor scope when resolving variable".to_owned(),
+            })
+            .map(|el| el.as_ref())?;
+        }
+
+        Ok(parent)
+    }
 }
 
 impl<T: Display> Display for Scope<T> {

loxrs_env/src/scope.rs

@@ -21,19 +21,31 @@ fn basics() {
 #[test]
 fn scope_assignment() {
     let scope = Rc::new(Scope::default());
-    let child = Scope::from_parent(Rc::clone(&scope));
 
     assert!(scope.get("foo").is_err());
     scope.define("foo", "bar".to_owned());
     assert!(scope.get("foo").is_ok_and(|str| str == "bar"));
-    assert!(child.get("foo").is_ok_and(|str| str == "bar"));
+}
+
+#[test]
+fn ancestry() {
+    let grandparent: Rc<Scope<bool>> = Rc::new(Scope::default());
+    grandparent.define("grandy", true);
 
-    child.define("baz", "fff".to_owned());
-    assert!(child.get("baz").is_ok_and(|str| str == "fff"));
+    let parent = Scope::from_parent(Rc::clone(&grandparent));
 
-    assert!(scope.get("baz").is_err());
-    assert!(scope.assign("baz", "bar".to_owned()).is_err());
+    parent.define("parent", true);
+    let child = Scope::from_parent(Rc::clone(&parent));
+
+    child.define("child", true);
+
+    assert!(child.get_at(0, "child").is_ok_and(|el| el));
+    assert!(child.get_at(1, "parent").is_ok_and(|el| el));
+    assert!(child.get_at(2, "grandy").is_ok_and(|el| el));
+
+    assert!(grandparent.assign_at(33, "foo", true).is_err());
+    assert!(grandparent.assign_at(1, "bar", true).is_err());
+    assert!(grandparent.assign_at(0, "works", true).is_ok());
 
-    assert!(child.assign("baz", "bar".to_owned()).is_ok());
-    assert!(child.get("baz").is_ok());
+    assert!(child.get_at(2, "works").is_ok_and(|el| el));
 }

loxrs_env/src/scope/test.rs

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+uuid = { version = "0.8.2", features = ["v4"] }
 backtrace-on-stack-overflow = "0.3.0"
 env_logger = "0.11.3"
 log = "0.4.21"

loxrs_interpreter/Cargo.toml

@@ -1,10 +1,26 @@
+use std::collections::HashMap;
 use std::fmt::Debug;
 use std::rc::Rc;
+use std::{cell::RefCell, fmt::Display};
 
-use super::Value;
+use super::{Expr, Value};
 use loxrs_env::Scope;
 
 #[derive(Debug, Clone)]
 pub struct Interpreter {
     pub scope: Rc<Scope<Value>>,
+    pub globals: Rc<Scope<Value>>,
+    pub locals: RefCell<HashMap<Expr, usize>>,
+}
+
+impl Display for Interpreter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "\nInterpreter: <locals: [")?;
+
+        for (k, v) in self.locals.borrow().iter() {
+            writeln!(f, "  ({}: {}) ", k, v)?;
+        }
+
+        write!(f, "]>")
+    }
 }

loxrs_interpreter/src/lox/entities/eval.rs

@@ -1,4 +1,7 @@
 use std::fmt::{self, Display};
+use std::hash::Hash;
+
+use uuid::Uuid;
 
 use super::{stmt::StmtBlock, Literal, Token};
 
@@ -15,7 +18,36 @@ fn parenthesize<T: Display>(name: &str, expressions: Vec<&T>) -> String {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Expr {
+pub struct Expr {
+    id: Uuid,
+    pub kind: ExprKind,
+}
+
+impl Eq for Expr {}
+
+impl Expr {
+    pub fn new(kind: ExprKind) -> Self {
+        Self {
+            id: Uuid::new_v4(),
+            kind,
+        }
+    }
+}
+
+impl Hash for Expr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
+impl fmt::Display for Expr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Expr<[id: {}], [kind: {}]>", self.id, self.kind)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ExprKind {
     Unary(Box<ExprUnary>),
     Binary(Box<ExprBinary>),
     Call(Box<ExprCall>),
@@ -24,7 +56,7 @@ pub enum Expr {
     Grouping(Box<ExprGrouping>),
     Function(Box<ExprFunction>),
     Var(Token),
-    Assign(Token, Box<ExprAssign>),
+    Assign(Box<ExprAssign>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -33,6 +65,28 @@ pub struct ExprFunction {
     pub body: StmtBlock,
 }
 
+impl Display for ExprFunction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("[ExprFunction]")
+            .field("params", &self.params)
+            .field("body", &self.body)
+            .finish()
+
+        // let params: Vec<&str> = self
+        //     .params
+        //     .iter()
+        //     .map(|el| el.extract_identifier_str().unwrap())
+        //     .collect();
+        //
+        // write!(f, "Expr[Function] ")?;
+        // if !params.is_empty() {
+        //     write!(f, "params: [{:?}] ", params)?;
+        // }
+        //
+        // write!(f, "body:\n  {}", self.body)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct ExprCall {
     pub callee: Expr,
@@ -42,6 +96,7 @@ pub struct ExprCall {
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct ExprAssign {
+    pub name: Token,
     pub expression: Expr,
 }
 
@@ -70,7 +125,7 @@ pub struct ExprLogical {
     pub operator: Token,
 }
 
-impl fmt::Display for Expr {
+impl fmt::Display for ExprKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
@@ -96,11 +151,13 @@ impl fmt::Display for Expr {
                     vec![&logical.left, &logical.right]
                 ),
                 Self::Literal(value) => value.to_string(),
-                Self::Var(var) => var
-                    .literal
-                    .clone()
-                    .map_or("None".to_string(), |t| t.to_string()),
-                Self::Assign(token, expr) => format!("token: {}, expr: {}", token, expr.expression),
+                Self::Var(var) => var.literal.clone().map_or("None".to_string(), |t| format!(
+                    "line: {}, col: {}, {}",
+                    var.line, var.column, t
+                )
+                .to_string()),
+                Self::Assign(assign) =>
+                    format!("target: {}, expr: {}", assign.name, assign.expression),
             }
         )
     }

loxrs_interpreter/src/lox/entities/expr.rs

@@ -7,6 +7,12 @@ use std::fmt::Result as fmt_result;
 use std::fmt::{Debug, Formatter};
 use std::rc::Rc;
 
+#[derive(Clone, PartialEq, Debug)]
+pub enum FuncType {
+    Function,
+    None,
+}
+
 #[derive(Clone, PartialEq, Debug)]
 pub enum Func {
     Lox(Function),