chore: optimize method calls to be fast

Author: aymaneelmaini

src/chunk.h

@@ -34,6 +34,7 @@ typedef enum
     OP_JUMP_IF_FALSE,
     OP_LOOP,
     OP_CALL,
+    OP_INVOKE,
     OP_CLOSURE,
     OP_CLOSE_UPVALUE,
     OP_RETURN,

src/compiler.c

@@ -66,6 +66,7 @@ typedef struct
 typedef enum
 {
     TYPE_FUNCTION,
+    TYPE_INITIALIZER,
     TYPE_METHOD,
     TYPE_SCRIPT,
 } FunctionType;
@@ -201,7 +202,11 @@ static int emit_jump(u8 instruction)
 
 static void emit_return()
 {
-    emit_byte(OP_NIL);
+    if (current->type == TYPE_INITIALIZER)
+        emit_bytes(OP_GET_LOCAL, 0);
+    else
+        emit_byte(OP_NIL);
+
     emit_byte(OP_RETURN);
 }
 
@@ -525,6 +530,12 @@ static void dot(bool can_assign)
         expression();
         emit_bytes(OP_SET_PROPERTY, name);
     }
+    else if (match(TOKEN_LEFT_PAREN))
+    {
+        u8 arg_count = arguments_list();
+        emit_bytes(OP_INVOKE, name);
+        emit_byte(arg_count);
+    }
     else
     {
         emit_bytes(OP_GET_PROPERTY, name);
@@ -796,6 +807,9 @@ static void method()
     u8 constant = identifier_constant(&parser.previous);
 
     FunctionType type = TYPE_METHOD;
+    if (parser.previous.length == 4 && memcmp(parser.previous.start, "init", 4) == 0)
+        type = TYPE_INITIALIZER;
+
     function(type);
 
     emit_bytes(OP_METHOD, constant);
@@ -953,6 +967,9 @@ static void return_statement()
     }
     else
     {
+        if (current->type == TYPE_INITIALIZER)
+            error("Can't return an a value from an initializer");
+
         expression();
         consume(TOKEN_SEMICOLON, "Expect semicolon after return value;");
         emit_byte(OP_RETURN);

src/debug.c

@@ -7,6 +7,7 @@
 
 static int simple_instruction(const char* name, int offset);
 static int constant_instruction(const char* name, Chunk* chunk, int offset);
+static int invoke_instruction(const char* name, Chunk* chunk, int offset);
 static int byte_instruction(const char* name, Chunk* chunk, int offset);
 static int jump_instruction(const char* name, int sign, Chunk* chunk,
                             int offset);
@@ -89,6 +90,8 @@ 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_INVOKE:
+        return invoke_instruction("OP_INVOKE", chunk, offset);
     case OP_CLOSURE:
     {
         u8 constant = chunk->code[++offset];
@@ -152,6 +155,17 @@ static int constant_instruction(const char* name, Chunk* chunk, int offset)
     return offset + 2;
 }
 
+static int invoke_instruction(const char* name, Chunk* chunk, int offset)
+{
+    u8 constant = chunk->code[offset + 1];
+    u8 arg_count = chunk->code[offset + 2];
+
+    printf("%-16s (%d args) %4d '", name, arg_count, constant);
+    print_value(chunk->constants.values[constant]);
+    printf("\n");
+    return offset + 3;
+}
+
 static const char* token_type_to_string(TokenType type)
 {
     switch (type)

src/vm.c

@@ -1,3 +1,4 @@
+#include <endian.h>
 #include <linux/limits.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -168,6 +169,40 @@ static bool call_value(Value callee, int arg_count)
     return false;
 }
 
+static bool invoke_from_class(ObjClass* klass, ObjString* name, int arg_count)
+{
+    Value method;
+    if (!table_get(&klass->methods, name, &method))
+    {
+        runtime_error("Undefined property '%s'.", name->chars);
+        return false;
+    }
+
+    return call(AS_CLOSURE(method), arg_count);
+}
+
+static bool invoke(ObjString* name, int arg_count)
+{
+    Value receiver = peek(arg_count);
+
+    if (!IS_INSTANCE(receiver))
+    {
+        runtime_error("Only class have methods");
+        return false;
+    }
+
+    ObjInstance* instance = AS_INSTANCE(receiver);
+
+    Value value;
+    if (table_get(&instance->fields, name, &value))
+    {
+        vm.stack_top[-arg_count - 1] = value;
+        return call_value(value, arg_count);
+    }
+
+    return invoke_from_class(instance->klass, name, arg_count);
+}
+
 static bool bind_method(ObjClass* klass, ObjString* name)
 {
     Value method;
@@ -488,6 +523,16 @@ static InterpretResult run()
             frame = &vm.frames[vm.frame_count - 1];
             break;
         }
+        case OP_INVOKE:
+        {
+            ObjString* method = READ_STRING();
+            int        arg_count = READ_BYTE();
+            if (!invoke(method, arg_count))
+                return INTERPRET_RUNTIME_ERROR;
+
+            frame = &vm.frames[vm.frame_count - 1];
+            break;
+        }
         case OP_CLOSURE:
         {
             ObjFunction* function = AS_FUNCTION(READ_CONSTANT());