solve edge case for constants

3 files changed, 44 insertions, 12 deletions

diff --git a/src/compiler.rs b/src/compiler.rs
index 6607c7f..c0dacec 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -914,12 +914,19 @@ impl Compiler {
                 // Remove the function, since it's a constant and we already
                 // added it.
                 block.ops.pop().unwrap();
-                if let Entry::Occupied(entry) = self.unknown.entry(String::from(name)) {
+                let slot = if let Entry::Occupied(entry) = self.unknown.entry(String::from(name)) {
                     let (_, (slot, _)) = entry.remove_entry();
                     self.constants[slot] = self.constants.pop().unwrap();
-                    add_op(self, block, Op::Link(slot));
+                    slot
                 } else {
-                    add_op(self, block, Op::Link(self.constants.len() - 1));
+                    self.constants.len() - 1
+                };
+                add_op(self, block, Op::Link(slot));
+                if let Value::Function(_, block) = &self.constants[slot] {
+                    let needs_linking = block.borrow().upvalues.len() != 0;
+                    block.borrow_mut().constant = needs_linking;
+                } else {
+                    unreachable!();
                 }
                 return;
             }
diff --git a/src/lib.rs b/src/lib.rs
index c940a88..1bdcc00 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -151,7 +151,7 @@ impl From<&Type> for Value {
             Type::String => Value::String(Rc::new("".to_string())),
             Type::Function(_, _) => Value::Function(
                 Vec::new(),
-                Rc::new(RefCell::new(Block::empty_with_type(ty)))),
+                Rc::new(RefCell::new(Block::stubbed_block(ty)))),
         }
     }
 }
@@ -635,6 +635,8 @@ pub struct Block {
     ops: Vec<Op>,
     last_line_offset: usize,
     line_offsets: HashMap<usize, usize>,
+    linked: bool,
+    constant: bool,
 }
 
 impl Block {
@@ -647,12 +649,14 @@ impl Block {
             ops: Vec::new(),
             last_line_offset: 0,
             line_offsets: HashMap::new(),
+            linked: false,
+            constant: false,
         }
     }
 
     // Used to create empty functions.
-    fn empty_with_type(ty: &Type) -> Self {
-        let mut block = Block::new("/empty/", Path::new(""), 0);
+    fn stubbed_block(ty: &Type) -> Self {
+        let mut block = Block::new("/empty/", Path::new(""));
         block.ty = ty.clone();
         block
     }
@@ -854,6 +858,20 @@ mod tests {
         assert_errs!(run_string("a :: B()\n", true, Vec::new()), [ErrorKind::SyntaxError(_, _)]);
     }
 
+    #[test]
+    fn call_before_link() {
+        let prog = "
+a := 1
+f()
+c := 5
+
+f :: fn {
+    c <=> 5
+}
+        ";
+        assert_errs!(run_string(prog, true, Vec::new()), [ErrorKind::InvalidProgram, ErrorKind::RuntimeTypeError(_, _)]);
+    }
+
 
     macro_rules! test_multiple {
         ($mod:ident, $( $fn:ident : $prog:literal ),+ $( , )? ) => {
diff --git a/src/vm.rs b/src/vm.rs
index f5c1cf0..20125be 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -557,6 +557,13 @@ impl VM {
                     Value::Function(_, block) => {
                         self.push(Value::Function(Vec::new(), block.clone()));
 
+                        if block.borrow().constant && !block.borrow().linked {
+                            error!(self,
+                                ErrorKind::InvalidProgram,
+                                format!("Calling function '{}' before all captured variables are declared.",
+                                    block.borrow().name));
+                        }
+
                         let mut types = Vec::new();
                         for (slot, is_up, ty) in block.borrow().upvalues.iter() {
                             if *is_up {
@@ -667,10 +674,10 @@ impl VM {
             }
 
             Op::Link(slot) => {
-                println!("{:?}", self.constants);
-                println!("{:?} - {}", self.constant(slot), slot);
                 match self.constant(slot).clone() {
-                    Value::Function(_, _) => {}
+                    Value::Function(_, block) => {
+                        block.borrow_mut().linked = true;
+                    }
                     value => {
                         error!(self,
                             ErrorKind::TypeError(op, vec![Type::from(&value)]),
@@ -733,7 +740,7 @@ impl VM {
                     }
                     _ => {
                         error!(self,
-                            ErrorKind::TypeError(op, vec![Type::from(&self.stack[new_base])]),
+                            ErrorKind::InvalidProgram,
                             format!("Tried to call non-function {:?}", self.stack[new_base]));
                     }
                 }
@@ -773,7 +780,7 @@ impl VM {
         });
 
         if self.print_blocks {
-            println!("\n    [[{}]]\n", "TYPECHECK".purple());
+            println!("\n    [[{} - {}]]\n", "TYPECHECKING".purple(), self.frame().block.borrow().name);
             self.frame().block.borrow().debug_print();
         }
 
@@ -832,7 +839,7 @@ mod tests {
                  f := fn i: int {
                      i()
                  }",
-                 [ErrorKind::TypeError(_, _)]);
+                 [ErrorKind::InvalidProgram]);
 
         test_string!(wrong_params, "
                  f : fn -> int = fn a: int -> int {}",