Bound methods

Author: penelopeysm

src/compiler.cpp

@@ -129,7 +129,7 @@ using lox::scanner::TokenType;
 Parser::Parser(std::unique_ptr<Scanner> scanner, ObjFunction* fnptr, GC& gc)
     : scanner(std::move(scanner)), current(SENTINEL_EOF),
       previous(SENTINEL_EOF), errmsg(std::nullopt), gc(gc),
-      compiler(std::make_unique<Compiler>(fnptr)) {}
+      compiler(std::make_unique<Compiler>(fnptr, nullptr, false)) {}
 
 void Parser::advance() {
   previous = current;
@@ -139,7 +139,7 @@ void Parser::advance() {
   }
 }
 
-void Parser::function(bool define) {
+void Parser::function(bool is_class_method) {
   // Parse the name and arity of the function: that will let us create the
   // ObjFunction object
   consume_or_error(TokenType::IDENTIFIER, "expected function name");
@@ -150,8 +150,8 @@ void Parser::function(bool define) {
   size_t arity = 0;
   // TODO: This copies the string. Do we need to?
   auto new_fnptr = gc.alloc<ObjFunction>(fn_name, arity);
-  auto new_compiler =
-      std::make_unique<Compiler>(new_fnptr, std::move(compiler));
+  auto new_compiler = std::make_unique<Compiler>(new_fnptr, std::move(compiler),
+                                                 is_class_method);
   compiler = std::move(new_compiler);
   compiler->begin_scope();
   // Parse parameters (if there are any).
@@ -194,7 +194,7 @@ void Parser::function(bool define) {
       emit(upvalue.is_local ? 1 : 0);
       emit(static_cast<uint8_t>(upvalue.index));
     }
-    if (define) {
+    if (!is_class_method) {
       // This makes `fn_name` available either as a local variable (if it's in
       // an inner scope) or a global variable. However, we don't always want to
       // do that: for example if we're parsing a class method, then the
@@ -392,7 +392,7 @@ void Parser::declaration() {
   if (consume_if(TokenType::VAR)) {
     var_declaration();
   } else if (consume_if(TokenType::FUN)) {
-    function(true);
+    function(false);
   } else if (consume_if(TokenType::CLASS)) {
     class_declaration();
   } else {
@@ -441,7 +441,7 @@ void Parser::class_declaration() {
 void Parser::method() {
   // This parses the function body and emits code to create an ObjClosure and
   // put it at the top of the stack.
-  function(false);
+  function(true);
   // We then need to tell the VM to read the ObjClosure at the top of the stack
   // and store it in the method table of the current class. The book just calls
   // this 'METHOD' but I've chosen to give it a more descriptive name.
@@ -723,6 +723,13 @@ void Parser::number(bool _) {
   emit_constant(value);
 }
 
+void Parser::this_(bool _) {
+  // 1. We can't assign to this, hence the false.
+  // 2. We just treat 'this' like a local variable that happens to be at index
+  // 0.
+  variable(false);
+}
+
 void Parser::literal(bool _) {
   switch (previous.type) {
   case TokenType::FALSE:

src/compiler.hpp

@@ -32,20 +32,18 @@ struct Local {
 
 class Compiler {
 public:
-  Compiler(ObjFunction* fnptr)
-      : scope_depth(0), current_function(fnptr), is_top_level(true),
-        parent(nullptr) {
-    // Reserve slot 0 of the stack for VM internal use. Note that this, on its
-    // own, will mess with the VM's state since this does not actually push to
-    // the stack at runtime. We have to 'balance' this out in the VM by pushing
-    // the pointer to the current function onto the stack before we start
-    // executing the chunk.
-    declare_local("");
-  }
-  Compiler(ObjFunction* fnptr, std::unique_ptr<Compiler> parent)
+  Compiler(ObjFunction* fnptr, std::unique_ptr<Compiler> parent,
+           bool is_class_method)
       : scope_depth(0), current_function(fnptr), is_top_level(false),
         parent(std::move(parent)) {
-    declare_local("");
+    if (is_class_method) {
+      // For a class method, we reserve slot 0 for the 'this' variable.
+      declare_local("this");
+    } else {
+      // For a non-class method, we reserve slot 0 to mimic the above, but
+      // we give it a name that can't ever be referred to.
+      declare_local("");
+    }
   }
 
   void mark_function_as_grey(GC& _gc);
@@ -152,6 +150,7 @@ class Parser {
   void string(bool can_assign);
   void variable(bool can_assign);
   void literal(bool can_assign);
+  void this_(bool can_assign);
   void define_variable(std::string_view var_name);
   void define_global_variable(std::string_view name);
   void named_variable(std::string_view lexeme, bool can_assign);
@@ -251,7 +250,7 @@ class Parser {
     case TokenType::SUPER:
       return Rule{NULL, NULL, Precedence::NONE};
     case TokenType::THIS:
-      return Rule{NULL, NULL, Precedence::NONE};
+      return Rule{&Parser::this_, NULL, Precedence::NONE};
     case TokenType::TRUE:
       return Rule{&Parser::literal, NULL, Precedence::NONE};
     case TokenType::VAR:

src/gc.cpp

@@ -127,6 +127,13 @@ void GC::gc() {
         mark_as_grey(fieldname);
         mark_as_grey(value);
       }
+      break;
+    }
+    case ObjType::BOUND_METHOD: {
+      auto p = static_cast<ObjBoundMethod*>(objptr);
+      mark_as_grey(p->receiver);
+      mark_as_grey(p->method);
+      break;
     }
     }
 

src/value.hpp

@@ -23,7 +23,8 @@ enum class ObjType {
   CLOSURE,
   NATIVE_FUNCTION,
   CLASS,
-  INSTANCE
+  INSTANCE,
+  BOUND_METHOD
 };
 
 // Forward declarations
@@ -175,6 +176,23 @@ class ObjInstance : public Obj {
   static constexpr std::string_view static_type_name = "ObjInstance";
 };
 
+class ObjBoundMethod : public Obj {
+public:
+  ObjInstance* receiver;
+  ObjClosure* method;
+
+  ObjBoundMethod(ObjInstance* receiver, ObjClosure* method)
+      : Obj(static_type), receiver(receiver), method(method) {}
+
+  std::string to_repr() const override {
+    return "<bound method " + method->to_repr() + " of " + receiver->to_repr() +
+           ">";
+  }
+
+  static constexpr ObjType static_type = ObjType::BOUND_METHOD;
+  static constexpr std::string_view static_type_name = "ObjBoundMethod";
+};
+
 template <typename T> T* as_objptr(Value value, const std::string& error_msg) {
   if (!std::holds_alternative<Obj*>(value)) {
     throw std::runtime_error(error_msg);

src/vm.cpp

@@ -486,9 +486,10 @@ InterpretResult VM::run() {
           auto classmethods = instanceptr->klass->methods;
           auto method_itr = classmethods.find(property_name);
           if (method_itr != classmethods.end()) {
-            // TODO: bind `this`
             ObjClosure* method_closure = method_itr->second;
-            stack_replace_top(method_closure);
+            ObjBoundMethod* bound_method =
+                _gc.alloc<ObjBoundMethod>(instanceptr, method_closure);
+            stack_replace_top(bound_method);
           } else {
             // OK, it really wasn't found
             throw std::runtime_error("undefined property '" +
@@ -594,6 +595,13 @@ InterpretResult VM::run() {
           stack_replace_top(inst);
           break;
         }
+        case ObjType::BOUND_METHOD: {
+          auto bound_method_ptr = static_cast<ObjBoundMethod*>(objptr);
+          // Stick `this` just before the arguments.
+          stack[stack.size() - 1 - nargs] = bound_method_ptr->receiver;
+          call(bound_method_ptr->method, nargs);
+          break;
+        }
         default: {
           throw std::runtime_error("can only call closure or native function");
         }

test.lox

@@ -1,5 +1,7 @@
 class Num {
-   a() { return 1; }
+   a(x) { return 1 + x + this.b; }
 }
 
-print Num().a();
+var n = Num();
+n.b = 2;
+print n.a(3);