Merge pull request #206 from tjhance/static_class_method

staticmethods and classmethods

src/runtime/builtin_modules/builtins.cpp

@@ -827,5 +827,7 @@ void setupBuiltins() {
     builtins_module->giveAttr("complex", complex_cls);
     builtins_module->giveAttr("super", super_cls);
     builtins_module->giveAttr("property", property_cls);
+    builtins_module->giveAttr("staticmethod", staticmethod_cls);
+    builtins_module->giveAttr("classmethod", classmethod_cls);
 }
 }

src/runtime/descr.cpp

@@ -70,6 +70,44 @@ static Box* propertySet(Box* self, Box* obj, Box* val) {
     return None;
 }
 
+static Box* staticmethodNew(Box* cls, Box* f) {
+    RELEASE_ASSERT(cls == staticmethod_cls, "");
+    return new BoxedStaticmethod(f);
+}
+
+static Box* staticmethodGet(Box* self, Box* obj, Box* type) {
+    RELEASE_ASSERT(self->cls == staticmethod_cls, "");
+
+    BoxedStaticmethod* sm = static_cast<BoxedStaticmethod*>(self);
+
+    if (sm->sm_callable == NULL) {
+        raiseExcHelper(RuntimeError, "uninitialized staticmethod object");
+    }
+
+    return sm->sm_callable;
+}
+
+static Box* classmethodNew(Box* cls, Box* f) {
+    RELEASE_ASSERT(cls == classmethod_cls, "");
+    return new BoxedClassmethod(f);
+}
+
+static Box* classmethodGet(Box* self, Box* obj, Box* type) {
+    RELEASE_ASSERT(self->cls == classmethod_cls, "");
+
+    BoxedClassmethod* cm = static_cast<BoxedClassmethod*>(self);
+
+    if (cm->cm_callable == NULL) {
+        raiseExcHelper(RuntimeError, "uninitialized classmethod object");
+    }
+
+    if (type == NULL) {
+        type = obj->cls;
+    }
+
+    return new BoxedInstanceMethod(type, cm->cm_callable);
+}
+
 void setupDescr() {
     member_cls->giveAttr("__name__", boxStrConstant("member"));
     member_cls->giveAttr("__get__", new BoxedFunction(boxRTFunction((void*)memberGet, UNKNOWN, 3)));
@@ -83,6 +121,23 @@ void setupDescr() {
     property_cls->giveAttr("__set__",
                            new BoxedFunction(boxRTFunction((void*)propertySet, UNKNOWN, 3, 0, false, false)));
     property_cls->freeze();
+
+    staticmethod_cls->giveAttr("__name__", boxStrConstant("staticmethod"));
+    staticmethod_cls->giveAttr("__new__",
+                               new BoxedFunction(boxRTFunction((void*)staticmethodNew, UNKNOWN, 5, 4, false, false),
+                                                 { None, None, None, None }));
+    staticmethod_cls->giveAttr("__get__",
+                               new BoxedFunction(boxRTFunction((void*)staticmethodGet, UNKNOWN, 3, 0, false, false)));
+    staticmethod_cls->freeze();
+
+
+    classmethod_cls->giveAttr("__name__", boxStrConstant("classmethod"));
+    classmethod_cls->giveAttr("__new__",
+                              new BoxedFunction(boxRTFunction((void*)classmethodNew, UNKNOWN, 5, 4, false, false),
+                                                { None, None, None, None }));
+    classmethod_cls->giveAttr("__get__",
+                              new BoxedFunction(boxRTFunction((void*)classmethodGet, UNKNOWN, 3, 0, false, false)));
+    classmethod_cls->freeze();
 }
 
 void teardownDescr() {

src/runtime/objmodel.h

@@ -105,7 +105,7 @@ struct CompareRewriteArgs;
 Box* compareInternal(Box* lhs, Box* rhs, int op_type, CompareRewriteArgs* rewrite_args);
 Box* getattrInternal(Box* obj, const std::string& attr, GetattrRewriteArgs* rewrite_args);
 Box* getattrInternalGeneral(Box* obj, const std::string& attr, GetattrRewriteArgs* rewrite_args, bool cls_only,
-                            bool for_call, bool* should_bind_out);
+                            bool for_call, Box** bind_obj_out, RewriterVar** r_bind_obj_out);
 
 Box* typeLookup(BoxedClass* cls, const std::string& attr, GetattrRewriteArgs* rewrite_args);
 

src/runtime/types.cpp

@@ -213,6 +213,33 @@ extern "C" void instancemethodGCHandler(GCVisitor* v, Box* b) {
     v->visit(im->func);
 }
 
+extern "C" void propertyGCHandler(GCVisitor* v, Box* b) {
+    BoxedProperty* prop = (BoxedProperty*)b;
+
+    if (prop->prop_get)
+        v->visit(prop->prop_get);
+    if (prop->prop_set)
+        v->visit(prop->prop_set);
+    if (prop->prop_del)
+        v->visit(prop->prop_del);
+    if (prop->prop_doc)
+        v->visit(prop->prop_doc);
+}
+
+extern "C" void staticmethodGCHandler(GCVisitor* v, Box* b) {
+    BoxedStaticmethod* sm = (BoxedStaticmethod*)b;
+
+    if (sm->sm_callable)
+        v->visit(sm->sm_callable);
+}
+
+extern "C" void classmethodGCHandler(GCVisitor* v, Box* b) {
+    BoxedClassmethod* cm = (BoxedClassmethod*)b;
+
+    if (cm->cm_callable)
+        v->visit(cm->cm_callable);
+}
+
 // This probably belongs in list.cpp?
 extern "C" void listGCHandler(GCVisitor* v, Box* b) {
     boxGCHandler(v, b);
@@ -291,7 +318,8 @@ extern "C" void closureGCHandler(GCVisitor* v, Box* b) {
 extern "C" {
 BoxedClass* object_cls, *type_cls, *none_cls, *bool_cls, *int_cls, *float_cls, *str_cls, *function_cls,
     *instancemethod_cls, *list_cls, *slice_cls, *module_cls, *dict_cls, *tuple_cls, *file_cls, *member_cls,
-    *closure_cls, *generator_cls, *complex_cls, *basestring_cls, *unicode_cls, *property_cls;
+    *closure_cls, *generator_cls, *complex_cls, *basestring_cls, *unicode_cls, *property_cls, *staticmethod_cls,
+    *classmethod_cls;
 
 
 BoxedTuple* EmptyTuple;
@@ -437,6 +465,18 @@ extern "C" Box* sliceNew(Box* cls, Box* start, Box* stop, Box** args) {
     return createSlice(start, stop, step);
 }
 
+Box* instancemethodGet(BoxedInstanceMethod* self, Box* obj, Box* type) {
+    RELEASE_ASSERT(self->cls == instancemethod_cls, "");
+
+    if (self->obj != NULL) {
+        return self;
+    }
+
+    // TODO subclass test
+
+    return new BoxedInstanceMethod(obj, self->func);
+}
+
 Box* instancemethodRepr(BoxedInstanceMethod* self) {
     if (self->obj)
         return boxStrConstant("<bound instancemethod object>");
@@ -700,7 +740,10 @@ void setupRuntime() {
     member_cls = new BoxedClass(type_cls, object_cls, NULL, 0, sizeof(BoxedMemberDescriptor), false);
     closure_cls = new BoxedClass(type_cls, object_cls, &closureGCHandler, offsetof(BoxedClosure, attrs),
                                  sizeof(BoxedClosure), false);
-    property_cls = new BoxedClass(type_cls, object_cls, NULL, 0, sizeof(BoxedProperty), false);
+    property_cls = new BoxedClass(type_cls, object_cls, &propertyGCHandler, 0, sizeof(BoxedProperty), false);
+    staticmethod_cls
+        = new BoxedClass(type_cls, object_cls, &staticmethodGCHandler, 0, sizeof(BoxedStaticmethod), false);
+    classmethod_cls = new BoxedClass(type_cls, object_cls, &classmethodGCHandler, 0, sizeof(BoxedClassmethod), false);
     attrwrapper_cls = new BoxedClass(type_cls, object_cls, &AttrWrapper::gcHandler, 0, sizeof(AttrWrapper), false);
 
     STR = typeFromClass(str_cls);
@@ -783,6 +826,8 @@ void setupRuntime() {
     instancemethod_cls->giveAttr("__name__", boxStrConstant("instancemethod"));
     instancemethod_cls->giveAttr("__repr__", new BoxedFunction(boxRTFunction((void*)instancemethodRepr, STR, 1)));
     instancemethod_cls->giveAttr("__eq__", new BoxedFunction(boxRTFunction((void*)instancemethodEq, UNKNOWN, 2)));
+    instancemethod_cls->giveAttr(
+        "__get__", new BoxedFunction(boxRTFunction((void*)instancemethodGet, UNKNOWN, 3, 0, false, false)));
     instancemethod_cls->freeze();
 
     slice_cls->giveAttr("__name__", boxStrConstant("slice"));

src/runtime/types.h

@@ -80,7 +80,8 @@ Box* getSysStdout();
 extern "C" {
 extern BoxedClass* object_cls, *type_cls, *bool_cls, *int_cls, *long_cls, *float_cls, *str_cls, *function_cls,
     *none_cls, *instancemethod_cls, *list_cls, *slice_cls, *module_cls, *dict_cls, *tuple_cls, *file_cls, *xrange_cls,
-    *member_cls, *method_cls, *closure_cls, *generator_cls, *complex_cls, *basestring_cls, *unicode_cls, *property_cls;
+    *member_cls, *method_cls, *closure_cls, *generator_cls, *complex_cls, *basestring_cls, *unicode_cls, *property_cls,
+    *staticmethod_cls, *classmethod_cls;
 }
 extern "C" { extern Box* None, *NotImplemented, *True, *False; }
 extern "C" {
@@ -404,6 +405,20 @@ public:
         : Box(property_cls), prop_get(get), prop_set(set), prop_del(del), prop_doc(doc) {}
 };
 
+class BoxedStaticmethod : public Box {
+public:
+    Box* sm_callable;
+
+    BoxedStaticmethod(Box* callable) : Box(staticmethod_cls), sm_callable(callable){};
+};
+
+class BoxedClassmethod : public Box {
+public:
+    Box* cm_callable;
+
+    BoxedClassmethod(Box* callable) : Box(classmethod_cls), cm_callable(callable){};
+};
+
 // TODO is there any particular reason to make this a Box, ie a python-level object?
 class BoxedClosure : public Box {
 public:

test/tests/method_ics.py

+# run_args: -n
+# statcheck: noninit_count('slowpath_classmethod_get') <= 10
+# statcheck: noninit_count('slowpath_staticmethod_get') <= 10
+# statcheck: noninit_count('slowpath_instancemethod_get') <= 10
+
+def _f_plain(self, a, b, c, d):
+    print 'in f', type(self), a, b, c, d
+
+@staticmethod
+def _g(a, b, c, d):
+    print 'in g', a, b, c, d
+
+@classmethod
+def _h(cls, a, b, c, d):
+    print 'in h', cls, a, b, c, d
+
+class C(object):
+    f_plain = _f_plain
+    g = _g
+    h = _h
+_f = C.f_plain
+C.f = _f
+
+def run():
+    c = C()
+
+    c.f(1, 2, 3, 4)
+    c.g(1, 2, 3, 4)
+    c.h(1, 2, 3, 4)
+
+    f1 = c.f
+    f1(1,2,3,4)
+
+    g1 = c.g
+    g1(1,2,3,4)
+
+    h1 = c.h
+    h1(1,2,3,4)
+
+    _f.__get__(c, C)(1,2,3,4)
+    _g.__get__(c, C)(1,2,3,4)
+    _h.__get__(c, C)(1,2,3,4)
+
+for i in xrange(1000):
+    run()

test/tests/static_class_methods.py

+class C(object):
+    @staticmethod
+    def f(a, b, c, d):
+        print a, b, c, d
+
+    @classmethod
+    def g(cls, a, b, c, d):
+        print cls, a, b, c, d
+
+c = C()
+c.f(1, 2, 3, 4)
+c.g(5, 6, 7, 8)
+
+C.f(9, 10, 11, 12)
+C.f(13, 14, 15, 16)
+
+@staticmethod
+def f(a, b, c, d):
+    print a, b, c, d
+
+@classmethod
+def g(cls, a, b, c, d):
+    print cls, a, b, c, d
+
+f.__get__(c, C)(17, 18, 19, 20)
+g.__get__(c, C)(21, 22, 23, 24)