feat: implement inheritance, and start into accessing super

Author: aymaneelmaini

src/chunk.h

@@ -39,6 +39,8 @@ typedef enum
     OP_CLOSE_UPVALUE,
     OP_RETURN,
     OP_CLASS,
+    OP_INHERIT,
+    OP_GET_SUPER,
     OP_METHOD,
 } OpCode;
 

src/compiler.c

@@ -87,6 +87,7 @@ typedef struct ClassCompiler
 {
     struct ClassCompiler* enclosing;
     Token                 name;
+    bool                  has_super_class;
 } ClassCompiler;
 
 static bool immutable_globals[UINT8_MAX];
@@ -644,6 +645,28 @@ static void variable(bool can_assign)
     named_variable(parser.previous, can_assign);
 }
 
+static Token synthetic_token(const char* text)
+{
+    return (Token){.start = text,
+                   .length = (int)strlen(text)};
+}
+
+static void super_(bool can_assign)
+{
+    if (current_class == NULL)
+        error("Can't use 'super' outside of a class");
+    else if (!current_class->has_super_class)
+        error("Can't use 'super' in a class with no superclass");
+
+    consume(TOKEN_DOT, "Expect '.' after a super.");
+    consume(TOKEN_IDENTIFIER, "Expect super class method name.");
+    u8 name = identifier_constant(&parser.previous);
+
+    named_variable(synthetic_token("this"), false);
+    named_variable(synthetic_token("super"), false);
+    emit_bytes(OP_GET_SUPER, name);
+}
+
 static void this_(bool can_assign)
 {
     if (current_class == NULL)
@@ -707,8 +730,8 @@ ParseRule rules[] = {
     [TOKEN_OR]             =  { NULL,      or_,     PREC_OR          },
     [TOKEN_PRINT]          =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_RETURN]         =  { NULL,      NULL,    PREC_NONE        },
-    [TOKEN_SUPER]          =  { NULL,      NULL,    PREC_NONE        },
-    [TOKEN_THIS]           =  { this_,      NULL,   PREC_NONE        },
+    [TOKEN_SUPER]          =  { super_,     NULL,    PREC_NONE        },
+    [TOKEN_THIS]           =  { this_,     NULL,    PREC_NONE        },
     [TOKEN_TRUE]           =  { literal,   NULL,    PREC_NONE        },
     [TOKEN_VAR]            =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_WHILE]          =  { NULL,      NULL,    PREC_NONE        },
@@ -824,9 +847,28 @@ static void class_declaration()
     emit_bytes(OP_CLASS, name_constant);
     define_variable(name_constant, true);
 
-    ClassCompiler class_compiler = {.name = parser.previous, .enclosing = current_class};
+    ClassCompiler class_compiler = {.name = parser.previous,
+                                    .has_super_class = false,
+                                    .enclosing = current_class};
     current_class = &class_compiler;
 
+    if (match(TOKEN_COLON))
+    {
+        consume(TOKEN_IDENTIFIER, "Expect super class name.");
+        variable(false);
+
+        if (identifiers_equal(&class_name, &parser.previous))
+            error("A class can't inherit from itself");
+
+        begin_scope();
+        add_local(synthetic_token("super"), false);
+        define_variable(0, false);
+
+        named_variable(class_name, false);
+        emit_byte(OP_INHERIT);
+        class_compiler.has_super_class = true;
+    }
+
     named_variable(class_name, false);
     consume(TOKEN_LEFT_BRACE, "Expected '{' after class name");
     while (!check(TOKEN_RIGHT_BRACE) && !check(TOKEN_EOF))
@@ -836,6 +878,9 @@ static void class_declaration()
     consume(TOKEN_RIGHT_BRACE, "Expected '}' after class body");
     emit_byte(OP_POP);
 
+    if (class_compiler.has_super_class)
+        end_scope();
+
     current_class = current_class->enclosing;
 }
 

src/debug.c

@@ -116,6 +116,8 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return simple_instruction("OP_RETURN", offset);
     case OP_CLASS:
         return constant_instruction("OP_CLASS", chunk, offset);
+    case OP_INHERIT:
+        return simple_instruction("OP_INHERIT", offset);
     case OP_METHOD:
         return constant_instruction("OP_METHOD", chunk, offset);
     default:
@@ -188,6 +190,8 @@ static const char* token_type_to_string(TokenType type)
         return "PLUS";
     case TOKEN_SEMICOLON:
         return "SEMICOLON";
+    case TOKEN_COLON:
+        return "COLON";
     case TOKEN_SLASH:
         return "SLASH";
     case TOKEN_STAR:

src/scanner.c

@@ -252,6 +252,8 @@ Token scan_token()
         return make_token(TOKEN_RIGHT_BRACE);
     case ';':
         return make_token(TOKEN_SEMICOLON);
+    case ':':
+        return make_token(TOKEN_COLON);
     case ',':
         return make_token(TOKEN_COMMA);
     case '.':

src/scanner.h

@@ -14,6 +14,7 @@ typedef enum
     TOKEN_MINUS,
     TOKEN_PLUS,
     TOKEN_SEMICOLON,
+    TOKEN_COLON,
     TOKEN_SLASH,
     TOKEN_STAR,
 

src/vm.c

@@ -576,6 +576,18 @@ static InterpretResult run()
         case OP_CLASS:
             push(OBJ_VAL(new_class(READ_STRING())));
             break;
+        case OP_INHERIT:
+            Value super_class = peek(1);
+
+            if (!IS_CLASS(super_class))
+            {
+                runtime_error("Superclass must be a class");
+                return INTERPRET_RUNTIME_ERROR;
+            }
+            ObjClass* sub_class = AS_CLASS(peek(0));
+            table_add_all(&AS_CLASS(super_class)->methods, &sub_class->methods);
+            pop();  // sub_class
+            break;
         case OP_METHOD:
             define_method(READ_STRING());
             break;