cl-interpret: Make an attempt at closures

(It kinda sucks, but it emulates closures half decently)

compiler/cl-interpret/src/builtin.rs

@@ -71,6 +71,29 @@ builtins! {
             _ => Err(Error::TypeError)?,
         }))
     }
+    /// Lists the potential "upvars" (lifted environment) of a function
+    pub fn collect_upvars<env, _>(ConValue::Function(f)) -> IResult<ConValue> {
+        use crate::function::collect_upvars::collect_upvars;
+        for (name, bind) in collect_upvars(f.decl(), env) {
+            match bind {
+                Some(bind) =>println!("{name}: {bind}"),
+                None => println!("{name}: _"),
+            }
+        }
+        Ok(ConValue::Empty)
+    }
+
+    /// Lists the collected environment of a function.
+    pub fn upvars(ConValue::Function(f)) -> IResult<ConValue> {
+        let uv = f.upvars();
+        for (name, bind) in uv.iter() {
+            match bind {
+                Some(bind) =>println!("{name}: {bind}"),
+                None => println!("{name}: _"),
+            }
+        }
+        Ok(ConValue::Empty)
+    }
 }
 builtins! {
     const BINARY;
@@ -257,7 +280,7 @@ macro builtins (
     $(prefix = $prefix:literal)?
     const $defaults:ident $( = [$($additional_builtins:expr),*$(,)?])?;
     $(
-        $(#[$meta:meta])*$vis:vis fn $name:ident$(<$env:tt, $args:tt>)? ( $($($arg:tt),+$(,)?)? ) $(-> $rety:ty)?
+        $(#[$meta:meta])*$vis:vis fn $name:ident$(<$env:tt, $args:tt>)? ( $($($arg:pat),+$(,)?)? ) $(-> $rety:ty)?
             $body:block
     )*
 ) {
@@ -273,12 +296,13 @@ macro builtins (
             fn description(&self) -> &str { concat!("builtin ", stringify!($name), stringify!(($($($arg),*)?) )) }
         }
         impl Callable for $name {
-            #[allow(unused)]
+            #[allow(unused, irrefutable_let_patterns)]
             fn call(&self, env: &mut Environment, args: &[ConValue]) $(-> $rety)? {
-                // println!("{}", stringify!($name), );
                 $(let $env = env;
                 let $args = args;)?
-                $(let [$($arg),*] = to_args(args)?;)?
+                $(let [$($arg),*] = to_args(args)? else {
+                    Err(Error::TypeError)?
+                };)?
                 $body
             }
             fn name(&self) -> Sym { stringify!($name).into() }

compiler/cl-interpret/src/convalue.rs

@@ -1,14 +1,14 @@
 //! Values in the dynamically typed AST interpreter.
 //!
 //! The most permanent fix is a temporary one.
-use cl_ast::Sym;
+use cl_ast::{format::FmtAdapter, Sym};
 
 use super::{
     error::{Error, IResult},
     function::Function,
     BuiltIn, Callable, Environment,
 };
-use std::{ops::*, rc::Rc};
+use std::{collections::HashMap, ops::*, rc::Rc};
 
 type Integer = isize;
 
@@ -38,8 +38,10 @@ pub enum ConValue {
     RangeExc(Integer, Integer),
     /// An inclusive range
     RangeInc(Integer, Integer),
+    /// A value of a product type
+    Struct(Rc<(Sym, HashMap<Sym, ConValue>)>),
     /// A callable thing
-    Function(Function),
+    Function(Rc<Function>),
     /// A built-in function
     BuiltIn(&'static dyn BuiltIn),
 }
@@ -290,6 +292,18 @@ impl std::fmt::Display for ConValue {
                 }
                 ')'.fmt(f)
             }
+            ConValue::Struct(parts) => {
+                let (name, map) = parts.as_ref();
+                use std::fmt::Write;
+                if !name.is_empty() {
+                    write!(f, "{name}: ")?;
+                }
+                let mut f = f.delimit_with("{", "\n}");
+                for (k, v) in map.iter() {
+                    write!(f, "\n{k}: {v},")?;
+                }
+                Ok(())
+            }
             ConValue::Function(func) => {
                 write!(f, "{}", func.decl())
             }

compiler/cl-interpret/src/env.rs

@@ -1,4 +1,5 @@
 //! Lexical and non-lexical scoping for variables
+
 use super::{
     builtin::{BINARY, MISC, RANGE, UNARY},
     convalue::ConValue,
@@ -11,6 +12,7 @@ use std::{
     collections::HashMap,
     fmt::Display,
     ops::{Deref, DerefMut},
+    rc::Rc,
 };
 
 type StackFrame = HashMap<Sym, Option<ConValue>>;
@@ -18,12 +20,20 @@ type StackFrame = HashMap<Sym, Option<ConValue>>;
 /// Implements a nested lexical scope
 #[derive(Clone, Debug)]
 pub struct Environment {
+    global: Vec<(StackFrame, &'static str)>,
     frames: Vec<(StackFrame, &'static str)>,
 }
 
 impl Display for Environment {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for (frame, name) in self.frames.iter().rev() {
+        for (frame, name) in self
+            .global
+            .iter()
+            .rev()
+            .take(2)
+            .rev()
+            .chain(self.frames.iter())
+        {
             writeln!(f, "--- {name} ---")?;
             for (var, val) in frame {
                 write!(f, "{var}: ")?;
@@ -39,13 +49,14 @@ impl Display for Environment {
 impl Default for Environment {
     fn default() -> Self {
         Self {
-            frames: vec![
+            global: vec![
                 (to_hashmap(RANGE), "range ops"),
                 (to_hashmap(UNARY), "unary ops"),
                 (to_hashmap(BINARY), "binary ops"),
                 (to_hashmap(MISC), "builtins"),
                 (HashMap::new(), "globals"),
             ],
+            frames: vec![],
         }
     }
 }
@@ -58,8 +69,16 @@ impl Environment {
         Self::default()
     }
     /// Creates an [Environment] with no [builtins](super::builtin)
-    pub fn no_builtins(name: &'static str) -> Self {
-        Self { frames: vec![(Default::default(), name)] }
+    pub fn no_builtins() -> Self {
+        Self { global: vec![(Default::default(), "globals")], frames: vec![] }
+    }
+
+    pub fn push_frame(&mut self, name: &'static str, frame: StackFrame) {
+        self.frames.push((frame, name));
+    }
+
+    pub fn pop_frame(&mut self) -> Option<StackFrame> {
+        self.frames.pop().map(|f| f.0)
     }
 
     pub fn eval(&mut self, node: &impl Interpret) -> IResult<ConValue> {
@@ -88,6 +107,11 @@ impl Environment {
                 return Ok(var);
             }
         }
+        for (frame, _) in self.global.iter_mut().rev() {
+            if let Some(var) = frame.get_mut(&id) {
+                return Ok(var);
+            }
+        }
         Err(Error::NotDefined(id))
     }
     /// Resolves a variable immutably.
@@ -101,21 +125,34 @@ impl Environment {
                 _ => (),
             }
         }
+        for (frame, _) in self.global.iter().rev() {
+            match frame.get(&id) {
+                Some(Some(var)) => return Ok(var.clone()),
+                Some(None) => return Err(Error::NotInitialized(id)),
+                _ => (),
+            }
+        }
         Err(Error::NotDefined(id))
     }
     /// Inserts a new [ConValue] into this [Environment]
     pub fn insert(&mut self, id: Sym, value: Option<ConValue>) {
         if let Some((frame, _)) = self.frames.last_mut() {
             frame.insert(id, value);
+        } else if let Some((frame, _)) = self.global.last_mut() {
+            frame.insert(id, value);
         }
     }
     /// A convenience function for registering a [FnDecl] as a [Function]
     pub fn insert_fn(&mut self, decl: &FnDecl) {
         let FnDecl { name, .. } = decl;
-        let (name, function) = (name, Some(Function::new(decl).into()));
+        let (name, function) = (name, Rc::new(Function::new(decl)));
         if let Some((frame, _)) = self.frames.last_mut() {
-            frame.insert(*name, function);
+            frame.insert(*name, Some(ConValue::Function(function.clone())));
+        } else if let Some((frame, _)) = self.global.last_mut() {
+            frame.insert(*name, Some(ConValue::Function(function.clone())));
         }
+        // Tell the function to lift its upvars now, after it's been declared
+        function.lift_upvars(self);
     }
 }
 
@@ -130,9 +167,7 @@ impl Environment {
     /// Exits the scope, destroying all local variables and
     /// returning the outer scope, if there is one
     fn exit(&mut self) -> &mut Self {
-        if self.frames.len() > 2 {
-            self.frames.pop();
-        }
+        self.frames.pop();
         self
     }
 }

compiler/cl-interpret/src/function.rs

@@ -1,24 +1,45 @@
 //! Represents a block of code which lives inside the Interpreter
 
+use collect_upvars::collect_upvars;
+
 use super::{Callable, ConValue, Environment, Error, IResult, Interpret};
 use cl_ast::{Function as FnDecl, Param, Sym};
-use std::rc::Rc;
+use std::{
+    cell::{Ref, RefCell},
+    collections::HashMap,
+    rc::Rc,
+};
+
+pub mod collect_upvars;
+
+type Upvars = HashMap<Sym, Option<ConValue>>;
+
 /// Represents a block of code which persists inside the Interpreter
 #[derive(Clone, Debug)]
 pub struct Function {
     /// Stores the contents of the function declaration
     decl: Rc<FnDecl>,
-    // /// Stores the enclosing scope of the function
-    // env: Box<Environment>,
+    /// Stores data from the enclosing scopes
+    upvars: RefCell<Upvars>,
 }
 
 impl Function {
     pub fn new(decl: &FnDecl) -> Self {
-        Self { decl: decl.clone().into() }
+        // let upvars = collect_upvars(decl, env);
+        Self { decl: decl.clone().into(), upvars: Default::default() }
     }
     pub fn decl(&self) -> &FnDecl {
         &self.decl
     }
+    pub fn upvars(&self) -> Ref<Upvars> {
+        self.upvars.borrow()
+    }
+    pub fn lift_upvars(&self, env: &mut Environment) {
+        let upvars = collect_upvars(&self.decl, env);
+        if let Ok(mut self_upvars) = self.upvars.try_borrow_mut() {
+            *self_upvars = upvars;
+        }
+    }
 }
 
 impl Callable for Function {
@@ -28,6 +49,7 @@ impl Callable for Function {
     }
     fn call(&self, env: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
         let FnDecl { name, bind, body, sign: _ } = &*self.decl;
+
         // Check arg mapping
         if args.len() != bind.len() {
             return Err(Error::ArgNumber { want: bind.len(), got: args.len() });
@@ -35,12 +57,21 @@ impl Callable for Function {
         let Some(body) = body else {
             return Err(Error::NotDefined(*name));
         };
+
+        let upvars = self.upvars.take();
+        env.push_frame("upvars", upvars);
+
         // TODO: completely refactor data storage
         let mut frame = env.frame("fn args");
         for (Param { mutability: _, name }, value) in bind.iter().zip(args) {
             frame.insert(*name, Some(value.clone()));
         }
-        match body.interpret(&mut frame) {
+        let res = body.interpret(&mut frame);
+        drop(frame);
+        if let Some(upvars) = env.pop_frame() {
+            self.upvars.replace(upvars);
+        }
+        match res {
             Err(Error::Return(value)) => Ok(value),
             Err(Error::Break(value)) => Err(Error::BadBreak(value)),
             result => result,

compiler/cl-interpret/src/function/collect_upvars.rs

@@ -0,0 +1,105 @@
+//! Collects the "Upvars" of a function at the point of its creation, allowing variable capture
+use crate::{convalue::ConValue, env::Environment};
+use cl_ast::{ast_visitor::visit::*, Function, Let, Param, Path, PathPart, Sym};
+use std::collections::{HashMap, HashSet};
+
+pub fn collect_upvars(f: &Function, env: &Environment) -> super::Upvars {
+    CollectUpvars::new(env).get_upvars(f)
+}
+
+#[derive(Clone, Debug)]
+pub struct CollectUpvars<'env> {
+    env: &'env Environment,
+    upvars: HashMap<Sym, Option<ConValue>>,
+    blacklist: HashSet<Sym>,
+}
+
+impl<'env> CollectUpvars<'env> {
+    pub fn new(env: &'env Environment) -> Self {
+        Self { upvars: HashMap::new(), blacklist: HashSet::new(), env }
+    }
+    pub fn get_upvars(mut self, f: &cl_ast::Function) -> HashMap<Sym, Option<ConValue>> {
+        self.visit_function(f);
+        self.upvars
+    }
+
+    pub fn add_upvar(&mut self, name: &Sym) {
+        let Self { env, upvars, blacklist } = self;
+        if blacklist.contains(name) || upvars.contains_key(name) {
+            return;
+        }
+        if let Ok(upvar) = env.get(*name) {
+            upvars.insert(*name, Some(upvar));
+        }
+    }
+
+    pub fn bind_name(&mut self, name: &Sym) {
+        self.blacklist.insert(*name);
+    }
+}
+
+impl<'env, 'a> Visit<'a> for CollectUpvars<'env> {
+    fn visit_block(&mut self, b: &'a cl_ast::Block) {
+        let blacklist = self.blacklist.clone();
+
+        // visit the block
+        let cl_ast::Block { stmts } = b;
+        stmts.iter().for_each(|s| self.visit_stmt(s));
+
+        // restore the blacklist
+        self.blacklist = blacklist;
+    }
+
+    fn visit_let(&mut self, l: &'a cl_ast::Let) {
+        let Let { mutable, name, ty, init } = l;
+        self.visit_mutability(mutable);
+        if let Some(ty) = ty {
+            self.visit_ty(ty);
+        }
+        // visit the initializer, which may use the bound name
+        if let Some(init) = init {
+            self.visit_expr(init)
+        }
+        // a bound name can never be an upvar
+        self.blacklist.insert(*name);
+    }
+
+    fn visit_function(&mut self, f: &'a cl_ast::Function) {
+        let Function { name: _, sign: _, bind, body } = f;
+        // parameters can never be upvars
+        for Param { mutability: _, name } in bind {
+            self.bind_name(name);
+        }
+        if let Some(body) = body {
+            self.visit_block(body);
+        }
+    }
+
+    fn visit_for(&mut self, f: &'a cl_ast::For) {
+        let cl_ast::For { bind, cond, pass, fail } = f;
+        self.visit_expr(cond);
+        self.visit_else(fail);
+        self.bind_name(bind); // TODO: is bind only bound in the pass block?
+        self.visit_block(pass);
+    }
+
+    fn visit_path(&mut self, p: &'a cl_ast::Path) {
+        // TODO: path resolution in environments
+        let Path { absolute: false, parts } = p else {
+            return;
+        };
+        let [PathPart::Ident(name)] = parts.as_slice() else {
+            return;
+        };
+        self.add_upvar(name);
+    }
+
+    fn visit_fielder(&mut self, f: &'a cl_ast::Fielder) {
+        let cl_ast::Fielder { name, init } = f;
+        if let Some(init) = init {
+            self.visit_expr(init);
+        } else {
+            self.add_upvar(name); // fielder without init grabs from env
+        }
+    }
+}

compiler/cl-interpret/src/interpret.rs

@@ -406,6 +406,20 @@ impl Interpret for Member {
                 .get(*id as usize)
                 .cloned()
                 .ok_or(Error::OobIndex(*id as usize, v.len())),
+            (ConValue::Struct(parts), MemberKind::Struct(name)) => {
+                parts.1.get(name).cloned().ok_or(Error::NotDefined(*name))
+            }
+            (ConValue::Struct(parts), MemberKind::Call(name, args)) => {
+                let mut values = vec![];
+                for arg in &args.exprs {
+                    values.push(arg.interpret(env)?);
+                }
+                (parts.1)
+                    .get(name)
+                    .cloned()
+                    .ok_or(Error::NotDefined(*name))?
+                    .call(env, &values)
+            }
             (head, MemberKind::Call(name, args)) => {
                 let mut values = vec![head];
                 for arg in &args.exprs {
@@ -429,9 +443,29 @@ impl Interpret for Index {
 }
 impl Interpret for Structor {
     fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
-        todo!("struct construction in {env}")
+        let Self { to: Path { absolute: _, parts }, init } = self;
+        use std::collections::HashMap;
+
+        let name = match parts.last() {
+            Some(PathPart::Ident(name)) => *name,
+            Some(PathPart::SelfKw) => "self".into(),
+            Some(PathPart::SelfTy) => "Self".into(),
+            Some(PathPart::SuperKw) => "super".into(),
+            None => "".into(),
+        };
+
+        let mut map = HashMap::new();
+        for Fielder { name, init } in init {
+            let value = match init {
+                Some(init) => init.interpret(env)?,
+                None => env.get(*name)?,
+            };
+            map.insert(*name, value);
+        }
+        Ok(ConValue::Struct(Rc::new((name, map))))
     }
 }
+
 impl Interpret for Path {
     fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
         let Self { absolute: _, parts } = self;