feat: implement getter/setter expressions

Author: aymaneelmaini

src/chunk.h

@@ -18,6 +18,8 @@ typedef enum
     OP_SET_GLOBAL,
     OP_GET_UPVALUE,
     OP_SET_UPVALUE,
+    OP_GET_PROPERTY,
+    OP_SET_PROPERTY,
     OP_EQUAL,
     OP_GREATER,
     OP_LESS,

src/compiler.c

@@ -499,6 +499,22 @@ static void call(bool can_assign)
     emit_bytes(OP_CALL, arg_count);
 }
 
+static void dot(bool can_assign)
+{
+    consume(TOKEN_DOT, "Expected property name after '.'.");
+    u8 name = identifier_constant(&parser.previous);
+
+    if (can_assign && match(TOKEN_EQUAL))
+    {
+        expression();
+        emit_bytes(OP_SET_PROPERTY, name);
+    }
+    else
+    {
+        emit_bytes(OP_GET_PROPERTY, name);
+    }
+}
+
 static void literal(bool can_assign)
 {
     switch (parser.previous.type)
@@ -626,7 +642,7 @@ ParseRule rules[] = {
     [TOKEN_LEFT_BRACE]     =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_RIGHT_BRACE]    =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_COMMA]          =  { NULL,      NULL,    PREC_NONE        },
-    [TOKEN_DOT]            =  { NULL,      NULL,    PREC_NONE        },
+    [TOKEN_DOT]            =  { NULL,      dot,    PREC_NONE        },
     [TOKEN_MINUS]          =  { unary,     binary,  PREC_TERM        },
     [TOKEN_PLUS]           =  { NULL,      binary,  PREC_TERM        },
     [TOKEN_SEMICOLON]      =  { NULL,      NULL,    PREC_NONE        },

src/debug.c

@@ -57,6 +57,10 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return byte_instruction("OP_GET_UPVALUE", chunk, offset);
     case OP_SET_UPVALUE:
         return byte_instruction("OP_SET_UPVALUE", chunk, offset);
+    case OP_GET_PROPERTY:
+        return constant_instruction("OP_GET_PROPERTY", chunk, offset);
+    case OP_SET_PROPERTY:
+        return constant_instruction("OP_SET_PROPERTY", chunk, offset);
     case OP_EQUAL:
         return simple_instruction("OP_EQUAL", offset);
     case OP_GREATER:

src/vm.c

@@ -318,6 +318,42 @@ static InterpretResult run()
             *frame->closure->upvalues[slot]->location = peek(0);
             break;
         }
+        case OP_GET_PROPERTY:
+        {
+            if (!IS_INSTANCE(peek(0)))
+            {
+                runtime_error("Only instances can have properties.");
+                return INTERPRET_RUNTIME_ERROR;
+            }
+            ObjInstance* instance = AS_INSTANCE(peek(0));
+            ObjString*   name = READ_STRING();
+
+            Value value;
+            if (table_get(&instance->fields, name, &value))
+            {
+                pop();
+                push(value);
+                break;
+            }
+            runtime_error("Undefined property %s", name->chars);
+            return INTERPRET_RUNTIME_ERROR;
+        }
+        case OP_SET_PROPERTY:
+        {
+            if (!IS_INSTANCE(peek(1)))
+            {
+                runtime_error("Only instances have fields.");
+                return INTERPRET_RUNTIME_ERROR;
+            }
+
+            ObjInstance* instance = AS_INSTANCE(peek(1));
+            table_set(&instance->fields, READ_STRING(), peek(0));
+
+            Value value = pop();
+            pop();
+            push(value);
+            break;
+        }
         case OP_EQUAL:
         {
             Value v2 = pop();