feat: introduce closures and make a design change (wrap all functions with a closure even if not exists)

Author: aymaneelmaini

src/chunk.h

@@ -30,6 +30,7 @@ typedef enum
     OP_JUMP_IF_FALSE,
     OP_LOOP,
     OP_CALL,
+    OP_CLOSURE,
     OP_RETURN,
 } OpCode;
 

src/compiler.c

@@ -679,7 +679,7 @@ static void function(FunctionType type)
     block();
 
     ObjFunction* function = end_compiler();
-    emit_bytes(OP_CONSTANT, make_constant(OBJ_VAL(function)));
+    emit_bytes(OP_CLOSURE, make_constant(OBJ_VAL(function)));
 }
 
 static void fun_declaration()

src/debug.c

@@ -80,6 +80,15 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return jump_instruction("OP_JUMP_IF_FALSE", -1, chunk, offset);
     case OP_CALL:
         return byte_instruction("OP_CALL", chunk, offset);
+    case OP_CLOSURE:
+    {
+        u8 constant = chunk->code[++offset];
+        printf("%-16s %4d ", "OP_CLOSURE", constant);
+        print_value(chunk->constants.values[constant]);
+        printf("\n");
+
+        return offset;
+    }
     case OP_RETURN:
         return simple_instruction("OP_RETURN", offset);
     default:

src/memory.c

@@ -24,6 +24,11 @@ static void free_object(Obj* object)
 {
     switch (object->type)
     {
+    case OBJ_CLOSURE:
+    {
+        FREE(ObjClosure, object);
+        break;
+    }
     case OBJ_FUNCTION:
     {
         ObjFunction* function = (ObjFunction*)object;

src/object.c

@@ -23,6 +23,13 @@ static Obj* allocate_object(size_t size, ObjType type)
     return object;
 }
 
+ObjClosure* new_closure(ObjFunction* function)
+{
+    ObjClosure* closure = ALLOCATE_OBJ(ObjClosure, OBJ_CLOSURE);
+    closure->function = function;
+    return closure;
+}
+
 ObjFunction* new_function()
 {
     ObjFunction* function = ALLOCATE_OBJ(ObjFunction, OBJ_FUNCTION);
@@ -108,6 +115,11 @@ void print_object(Value value)
 
     switch (OBJ_TYPE(value))
     {
+    case OBJ_CLOSURE:
+    {
+        print_function(AS_CLOSURE(value)->function);
+        break;
+    }
     case OBJ_FUNCTION:
     {
         print_function(AS_FUNCTION(value));

src/object.h

@@ -7,6 +7,9 @@
 
 #define OBJ_TYPE(value) (AS_OBJ(value)->type)
 
+#define IS_CLOSURE(value) is_obj_type(value, OBJ_CLOSURE)
+#define AS_CLOSURE(value) ((ObjClosure*)AS_OBJ(value))
+
 #define IS_FUNCTION(value) is_obj_type(value, OBJ_FUNCTION);
 #define AS_FUNCTION(value) (((ObjFunction*)AS_OBJ(value)))
 
@@ -19,6 +22,7 @@
 
 typedef enum
 {
+    OBJ_CLOSURE,
     OBJ_FUNCTION,
     OBJ_NATIVE,
     OBJ_STRING,
@@ -55,6 +59,13 @@ struct ObjString
     u32   hash;
 };
 
+typedef struct
+{
+    Obj          obj;
+    ObjFunction* function;
+} ObjClosure;
+
+ObjClosure*  new_closure(ObjFunction* function);
 ObjFunction* new_function();
 ObjNative*   new_native(NativeFn function);
 ObjString*   take_string(char* chars, int length);

src/vm.c

@@ -33,7 +33,7 @@ static void runtime_error(const char* format, ...)
     for (int i = vm.frame_count - 1; i >= 0; i--)
     {
         CallFrame*   frame = &vm.frames[i];
-        ObjFunction* function = frame->function;
+        ObjFunction* function = frame->closure->function;
         size_t       instruction = frame->ip - function->chunk.code - 1;
 
         fprintf(stderr, "[line %d] in ", function->chunk.lines[instruction]);
@@ -89,12 +89,12 @@ static Value peek(int distance)
     return vm.stack_top[-1 - distance];
 }
 
-static bool call(ObjFunction* function, int arg_count)
+static bool call(ObjClosure* closure, int arg_count)
 {
-    if (function->arity != arg_count)
+    if (arg_count != closure->function->arity)
     {
-        runtime_error("Expected %d arguments but got %d.", function->arity,
-                      arg_count);
+        runtime_error("Expected %d arguments but got %d.",
+                      closure->function->arity, arg_count);
     }
     if (vm.frame_count == FRAMES_MAX)
     {
@@ -104,8 +104,8 @@ static bool call(ObjFunction* function, int arg_count)
         return false;
     }
     CallFrame* frame = &vm.frames[vm.frame_count++];
-    frame->function = function;
-    frame->ip = function->chunk.code;
+    frame->closure = closure;
+    frame->ip = closure->function->chunk.code;
     frame->slots = vm.stack_top - arg_count - 1;
     return true;
 }
@@ -116,10 +116,8 @@ static bool call_value(Value callee, int arg_count)
     {
         switch (OBJ_TYPE(callee))
         {
-        case OBJ_FUNCTION:
-        {
-            return call(AS_FUNCTION(callee), arg_count);
-        }
+        case OBJ_CLOSURE:
+            return call(AS_CLOSURE(callee), arg_count);
         case OBJ_NATIVE:
         {
             NativeFn native = AS_NATIVE(callee);
@@ -164,7 +162,8 @@ static InterpretResult run()
 
 #define READ_BYTE() (*frame->ip++)
 #define READ_SHORT() (frame->ip += 2, (u16)(frame->ip[-2] << 8) | frame->ip[-1])
-#define READ_CONSTANT() (frame->function->chunk.constants.values[READ_BYTE()])
+#define READ_CONSTANT()                                                        \
+    (frame->closure->function->chunk.constants.values[READ_BYTE()])
 #define READ_STRING() AS_STRING(READ_CONSTANT())
 #define BINARY_OP(value_type, op)                                              \
     do                                                                         \
@@ -190,8 +189,9 @@ static InterpretResult run()
             printf(" ]");
         }
         printf("\n");
-        disassemble_instruction(&frame->function->chunk,
-                                (int)(frame->ip - frame->function->chunk.code));
+        disassemble_instruction(
+            &frame->closure->function->chunk,
+            (int)(frame->ip - frame->closure->function->chunk.code));
 #endif
         u8 instruction;
         switch (instruction = READ_BYTE())
@@ -342,6 +342,13 @@ static InterpretResult run()
             frame = &vm.frames[vm.frame_count - 1];
             break;
         }
+        case OP_CLOSURE:
+        {
+            ObjFunction* function = AS_FUNCTION(READ_CONSTANT());
+            ObjClosure*  closure = new_closure(function);
+            push(OBJ_VAL(closure));
+            break;
+        }
         case OP_RETURN:
         {
             Value result = pop();
@@ -375,11 +382,10 @@ InterpretResult interpret(char* source)
         return INTERPRET_COMPILE_ERROR;
 
     push(OBJ_VAL(function));
-    call_value(OBJ_VAL(function), 0);
-    CallFrame* frame = &vm.frames[vm.frame_count++];
-    frame->function = function;
-    frame->ip = function->chunk.code;
-    frame->slots = vm.stack;
+    ObjClosure* closure = new_closure(function);
+    pop();
+    push(OBJ_VAL(closure));
+    call_value(OBJ_VAL(closure), 0);
 
     return run();
 }

src/vm.h

@@ -12,9 +12,9 @@
 
 typedef struct
 {
-    ObjFunction* function;
-    u8*          ip;
-    Value*       slots;
+    ObjClosure* closure;
+    u8*         ip;
+    Value*      slots;
 } CallFrame;
 
 typedef struct