feat: capture upvalues and store them in vm

Author: aymaneelmaini

src/chunk.h

@@ -33,6 +33,7 @@ typedef enum
     OP_LOOP,
     OP_CALL,
     OP_CLOSURE,
+    OP_CLOSE_UPVALUE,
     OP_RETURN,
 } OpCode;
 

src/compiler.c

@@ -52,6 +52,7 @@ typedef struct
 {
     Token name;
     int   depth;
+    bool  is_captured;
     bool  is_immutable;
 } Local;
 
@@ -237,6 +238,8 @@ static void init_compiler(Compiler* compiler, FunctionType type)
 
     Local* local = &current->locals[current->local_count++];
     local->depth = 0;
+    local->is_captured = false;
+    local->is_immutable = false;
     local->name.start = "";
     local->name.length = 0;
 }
@@ -270,7 +273,10 @@ static void end_scope()
            current->locals[current->local_count - 1].depth >
                current->scope_depth)
     {
-        emit_byte(OP_POP);
+        if (current->locals[current->local_count - 1].is_captured)
+            emit_byte(OP_CLOSE_UPVALUE);
+        else
+            emit_byte(OP_POP);
         current->local_count--;
     }
 }
@@ -338,7 +344,10 @@ static int resolve_upvalue(Compiler* compiler, Token* name)
 
     int local = resolve_local(compiler->enclosing, name);
     if (local != -1)
+    {
+        compiler->enclosing->locals[local].is_captured = true;
         return add_upvalue(compiler, (u8)local, true);
+    }
 
     int upvalue = resolve_upvalue(compiler->enclosing, name);
     if (upvalue != -1)
@@ -356,8 +365,9 @@ static void add_local(Token name, bool is_immutable)
     }
     Local* local = &current->locals[current->local_count++];
     local->name = name;
-    local->is_immutable = is_immutable;
     local->depth = -1;
+    local->is_captured = false;
+    local->is_immutable = is_immutable;
 }
 
 static void declare_variable(bool is_immutable)

src/debug.c

@@ -103,6 +103,8 @@ int disassemble_instruction(Chunk* chunk, int offset)
 
         return offset;
     }
+    case OP_CLOSE_UPVALUE:
+        return simple_instruction("OP_CLOSE_UPVALUE", offset);
     case OP_RETURN:
         return simple_instruction("OP_RETURN", offset);
     default:

src/object.c

@@ -113,6 +113,8 @@ ObjUpvalue* new_upvalue(Value* slot)
 {
     ObjUpvalue* upvalue = ALLOCATE_OBJ(ObjUpvalue, OBJ_UPVALUE);
     upvalue->location = slot;
+    upvalue->closed = NIL_VAL;
+    upvalue->next = NULL;
     return upvalue;
 }
 

src/object.h

@@ -61,10 +61,12 @@ struct ObjString
     u32   hash;
 };
 
-typedef struct
+typedef struct ObjUpvalue
 {
-    Obj    obj;
-    Value* location;
+    Obj                obj;
+    Value*             location;
+    Value              closed;
+    struct ObjUpvalue* next;
 } ObjUpvalue;
 
 typedef struct

src/vm.c

@@ -20,6 +20,7 @@ static void reset_stack()
 {
     vm.stack_top = vm.stack;
     vm.frame_count = 0;
+    vm.open_upvalues = NULL;
 }
 
 static void runtime_error(const char* format, ...)
@@ -136,9 +137,39 @@ static bool call_value(Value callee, int arg_count)
     return false;
 }
 
+static void close_upvalues(Value* last)
+{
+    while (vm.open_upvalues != NULL && vm.open_upvalues->location >= last)
+    {
+        ObjUpvalue* upvalue = vm.open_upvalues;
+        upvalue->closed = *upvalue->location;
+        upvalue->location = &upvalue->closed;
+        vm.open_upvalues->next = upvalue->next;
+    }
+}
+
 static ObjUpvalue* capture_upvalue(Value* local)
 {
+    ObjUpvalue* prev_upvalue = NULL;
+    ObjUpvalue* upvalue = vm.open_upvalues;
+
+    while (upvalue != NULL && upvalue->location > local)
+    {
+        prev_upvalue = upvalue;
+        upvalue = upvalue->next;
+    }
+
+    if (upvalue != NULL && upvalue->location == local)
+        return upvalue;
+
     ObjUpvalue* created_upvalue = new_upvalue(local);
+    created_upvalue->next = upvalue;
+
+    if (prev_upvalue == NULL)
+        vm.open_upvalues = created_upvalue;
+    else
+        prev_upvalue->next = created_upvalue;
+
     return created_upvalue;
 }
 
@@ -377,9 +408,16 @@ static InterpretResult run()
             }
             break;
         }
+        case OP_CLOSE_UPVALUE:
+        {
+            close_upvalues(vm.stack_top - 1);
+            pop();
+            break;
+        }
         case OP_RETURN:
         {
             Value result = pop();
+            close_upvalues(frame->slots);
 
             if (--vm.frame_count == 0)
             {

src/vm.h

@@ -25,7 +25,8 @@ typedef struct
     Value*    stack_top;
     Table     globals;
     Table     strings;  // for string interning just like (string pool in java)
-    Obj*      objects;
+    ObjUpvalue* open_upvalues;
+    Obj*        objects;
 } VM;
 
 typedef enum