Move most descriptor-related code into descr.cpp

I think it now contains the same types that CPython's
descrobject.c handles.

src/CMakeLists.txt

@@ -28,7 +28,6 @@ add_library(PYSTON_OBJECTS OBJECT ${OPTIONAL_SRCS}
 		asm_writing/rewriter.cpp
 		capi/abstract.cpp
 		capi/codecs.cpp
-		capi/descrobject.cpp
 		capi/errors.cpp
 		capi/modsupport.cpp
 		capi/object.cpp

src/capi/descrobject.cpp

-// Copyright (c) 2014-2015 Dropbox, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "capi/types.h"
-#include "runtime/objmodel.h"
-#include "runtime/rewrite_args.h"
-
-namespace pyston {
-
-Box* BoxedMethodDescriptor::__call__(BoxedMethodDescriptor* self, Box* obj, BoxedTuple* varargs, Box** _args) {
-    STAT_TIMER(t0, "us_timer_boxedmethoddescriptor__call__", 10);
-    BoxedDict* kwargs = static_cast<BoxedDict*>(_args[0]);
-
-    assert(self->cls == method_cls);
-    assert(varargs->cls == tuple_cls);
-    assert(kwargs->cls == dict_cls);
-
-    int ml_flags = self->method->ml_flags;
-
-    int call_flags;
-    if (ml_flags & METH_CLASS) {
-        if (!isSubclass(obj->cls, type_cls))
-            raiseExcHelper(TypeError, "descriptor '%s' requires a type but received a '%s'", self->method->ml_name,
-                           getFullTypeName(obj).c_str());
-        call_flags = ml_flags & (~METH_CLASS);
-    } else {
-        if (!isSubclass(obj->cls, self->type))
-            raiseExcHelper(TypeError, "descriptor '%s' requires a '%s' object but received a '%s'",
-                           self->method->ml_name, getFullNameOfClass(self->type).c_str(), getFullTypeName(obj).c_str());
-        call_flags = ml_flags;
-    }
-
-    threading::GLPromoteRegion _gil_lock;
-
-    Box* rtn;
-    if (call_flags == METH_NOARGS) {
-        RELEASE_ASSERT(varargs->size() == 0, "");
-        RELEASE_ASSERT(kwargs->d.size() == 0, "");
-        rtn = (Box*)self->method->ml_meth(obj, NULL);
-    } else if (call_flags == METH_VARARGS) {
-        RELEASE_ASSERT(kwargs->d.size() == 0, "");
-        rtn = (Box*)self->method->ml_meth(obj, varargs);
-    } else if (call_flags == (METH_VARARGS | METH_KEYWORDS)) {
-        rtn = (Box*)((PyCFunctionWithKeywords)self->method->ml_meth)(obj, varargs, kwargs);
-    } else if (call_flags == METH_O) {
-        RELEASE_ASSERT(kwargs->d.size() == 0, "");
-        RELEASE_ASSERT(varargs->size() == 1, "");
-        rtn = (Box*)self->method->ml_meth(obj, varargs->elts[0]);
-    } else {
-        RELEASE_ASSERT(0, "0x%x", call_flags);
-    }
-
-    checkAndThrowCAPIException();
-    assert(rtn && "should have set + thrown an exception!");
-    return rtn;
-}
-
-Box* BoxedMethodDescriptor::callInternal(BoxedFunctionBase* f, CallRewriteArgs* rewrite_args, ArgPassSpec argspec,
-                                         Box* arg1, Box* arg2, Box* arg3, Box** args,
-                                         const std::vector<BoxedString*>* keyword_names) {
-    // TODO: could also handle cases where we have starargs but no positional args,
-    // and similarly for kwargs but no keywords
-    if (!rewrite_args || argspec.has_kwargs || argspec.has_starargs || argspec.num_keywords > 0 || argspec.num_args > 4)
-        return callFunc(f, rewrite_args, argspec, arg1, arg2, arg3, args, keyword_names);
-
-    assert(argspec.num_args >= 2);
-    int passed_varargs = argspec.num_args - 2;
-
-    assert(arg1->cls == method_cls);
-    BoxedMethodDescriptor* self = static_cast<BoxedMethodDescriptor*>(arg1);
-    Box* obj = arg2;
-    RewriterVar* r_obj = rewrite_args->arg2;
-
-    // We could also guard on the fields of the method object, but lets just guard on the object itself
-    // for now.
-    // TODO: what if it gets GC'd?
-    rewrite_args->arg1->addGuard((intptr_t)self);
-
-    int ml_flags = self->method->ml_flags;
-    RELEASE_ASSERT((ml_flags & METH_CLASS) == 0, "unimplemented");
-    if (!isSubclass(obj->cls, self->type))
-        raiseExcHelper(TypeError, "descriptor '%s' requires a '%s' object but received a '%s'", self->method->ml_name,
-                       getFullNameOfClass(self->type).c_str(), getFullTypeName(obj).c_str());
-    r_obj->addAttrGuard(offsetof(Box, cls), (intptr_t)obj->cls);
-    int call_flags = ml_flags;
-
-    Box* rtn;
-    RewriterVar* r_rtn;
-    if (call_flags == METH_NOARGS) {
-        RELEASE_ASSERT(passed_varargs == 0, "");
-        rtn = (Box*)(self->method->ml_meth)(obj, NULL);
-        r_rtn = rewrite_args->rewriter->call(true, (void*)self->method->ml_meth, r_obj,
-                                             rewrite_args->rewriter->loadConst(0, Location::forArg(1)));
-    } else if (call_flags & METH_VARARGS) {
-        RELEASE_ASSERT(call_flags == METH_VARARGS || call_flags == (METH_VARARGS | METH_KEYWORDS), "");
-
-        Box* varargs;
-        RewriterVar* r_varargs;
-
-        if (passed_varargs == 0) {
-            varargs = EmptyTuple;
-            r_varargs = rewrite_args->rewriter->loadConst((intptr_t)EmptyTuple, Location::forArg(1));
-        } else if (passed_varargs == 1) {
-            varargs = BoxedTuple::create1(arg3);
-            r_varargs = rewrite_args->rewriter->call(false, (void*)BoxedTuple::create1, rewrite_args->arg3);
-        } else if (passed_varargs == 2) {
-            varargs = BoxedTuple::create2(arg3, args[0]);
-            r_varargs = rewrite_args->rewriter->call(false, (void*)BoxedTuple::create2, rewrite_args->arg3,
-                                                     rewrite_args->args->getAttr(0, Location::forArg(1)));
-        } else {
-            RELEASE_ASSERT(0, "");
-        }
-
-        if (call_flags & METH_KEYWORDS) {
-            Box* kwargs = NULL;
-            RewriterVar* r_kwargs = rewrite_args->rewriter->loadConst(0);
-            rtn = (Box*)((PyCFunctionWithKeywords)self->method->ml_meth)(obj, varargs, kwargs);
-            r_rtn = rewrite_args->rewriter->call(true, (void*)self->method->ml_meth, r_obj, r_varargs, r_kwargs);
-        } else {
-            rtn = (Box*)(self->method->ml_meth)(obj, varargs);
-            r_rtn = rewrite_args->rewriter->call(true, (void*)self->method->ml_meth, r_obj, r_varargs);
-        }
-    } else if (call_flags == METH_O) {
-        RELEASE_ASSERT(passed_varargs == 1, "");
-        rtn = (Box*)(self->method->ml_meth)(obj, arg3);
-        r_rtn = rewrite_args->rewriter->call(true, (void*)self->method->ml_meth, r_obj, rewrite_args->arg3);
-    } else {
-        RELEASE_ASSERT(0, "0x%x", call_flags);
-    }
-
-    rewrite_args->rewriter->call(true, (void*)checkAndThrowCAPIException);
-    rewrite_args->out_rtn = r_rtn;
-    rewrite_args->out_success = true;
-    return rtn;
-}
-}

src/capi/types.h

@@ -24,18 +24,6 @@ namespace pyston {
 typedef PyObject* (*wrapperfunc)(PyObject* self, PyObject* args, void* wrapped);
 typedef PyObject* (*wrapperfunc_kwds)(PyObject* self, PyObject* args, void* wrapped, PyObject* kwds);
 
-struct wrapper_def {
-    const llvm::StringRef name;
-    int offset;
-    void* function;      // "generic" handler that gets put in the tp_* slot which proxies to the python version
-    wrapperfunc wrapper; // "wrapper" that ends up getting called by the Python-visible WrapperDescr
-    const llvm::StringRef doc;
-    int flags;
-    // exists in CPython: PyObject *name_strobj
-};
-
-extern "C" BoxedClass* capifunc_cls, *wrapperdescr_cls, *wrapperobject_cls;
-
 class BoxedCApiFunction : public Box {
 public:
     PyMethodDef* method_def;
@@ -132,114 +120,6 @@ static_assert(offsetof(BoxedCApiFunction, method_def) == offsetof(PyCFunctionObj
 static_assert(offsetof(BoxedCApiFunction, passthrough) == offsetof(PyCFunctionObject, m_self), "");
 static_assert(offsetof(BoxedCApiFunction, module) == offsetof(PyCFunctionObject, m_module), "");
 
-class BoxedWrapperDescriptor : public Box {
-public:
-    const wrapper_def* wrapper;
-    BoxedClass* type;
-    void* wrapped;
-    BoxedWrapperDescriptor(const wrapper_def* wrapper, BoxedClass* type, void* wrapped)
-        : wrapper(wrapper), type(type), wrapped(wrapped) {}
-
-    DEFAULT_CLASS(wrapperdescr_cls);
-
-    static Box* __get__(BoxedWrapperDescriptor* self, Box* inst, Box* owner);
-    static Box* descr_get(Box* self, Box* inst, Box* owner) noexcept;
-    static Box* __call__(BoxedWrapperDescriptor* descr, PyObject* self, BoxedTuple* args, Box** _args);
-
-    static void gcHandler(GCVisitor* v, Box* _o) {
-        assert(_o->cls == wrapperdescr_cls);
-        BoxedWrapperDescriptor* o = static_cast<BoxedWrapperDescriptor*>(_o);
-
-        boxGCHandler(v, o);
-        v->visit(o->type);
-    }
-};
-
-class BoxedWrapperObject : public Box {
-public:
-    BoxedWrapperDescriptor* descr;
-    Box* obj;
-
-    BoxedWrapperObject(BoxedWrapperDescriptor* descr, Box* obj) : descr(descr), obj(obj) {}
-
-    DEFAULT_CLASS(wrapperobject_cls);
-
-    static Box* __call__(BoxedWrapperObject* self, Box* args, Box* kwds) {
-        STAT_TIMER(t0, "us_timer_boxedwrapperobject__call__", (self->cls->is_user_defined ? 1 : 2));
-
-        assert(self->cls == wrapperobject_cls);
-        assert(args->cls == tuple_cls);
-        assert(kwds->cls == dict_cls);
-
-        int flags = self->descr->wrapper->flags;
-        wrapperfunc wrapper = self->descr->wrapper->wrapper;
-        assert(self->descr->wrapper->offset > 0);
-
-        Box* rtn;
-        if (flags == PyWrapperFlag_KEYWORDS) {
-            wrapperfunc_kwds wk = (wrapperfunc_kwds)wrapper;
-            rtn = (*wk)(self->obj, args, self->descr->wrapped, kwds);
-        } else if (flags == PyWrapperFlag_PYSTON || flags == 0) {
-            rtn = (*wrapper)(self->obj, args, self->descr->wrapped);
-        } else {
-            RELEASE_ASSERT(0, "%d", flags);
-        }
-
-        checkAndThrowCAPIException();
-        assert(rtn && "should have set + thrown an exception!");
-        return rtn;
-    }
-
-    static void gcHandler(GCVisitor* v, Box* _o) {
-        assert(_o->cls == wrapperobject_cls);
-        BoxedWrapperObject* o = static_cast<BoxedWrapperObject*>(_o);
-
-        boxGCHandler(v, o);
-        v->visit(o->obj);
-    }
-};
-
-class BoxedMethodDescriptor : public Box {
-public:
-    PyMethodDef* method;
-    BoxedClass* type;
-
-    BoxedMethodDescriptor(PyMethodDef* method, BoxedClass* type) : method(method), type(type) {}
-
-    DEFAULT_CLASS(method_cls);
-
-    static Box* __get__(BoxedMethodDescriptor* self, Box* inst, Box* owner) {
-        RELEASE_ASSERT(self->cls == method_cls, "");
-
-        // CPython handles this differently: they create the equivalent of different BoxedMethodDescriptor
-        // objects but with different class objects, which define different __get__ and __call__ methods.
-        if (self->method->ml_flags & METH_CLASS)
-            return boxInstanceMethod(owner, self, self->type);
-
-        if (self->method->ml_flags & METH_STATIC)
-            Py_FatalError("unimplemented");
-        if (self->method->ml_flags & METH_COEXIST)
-            Py_FatalError("unimplemented");
-
-        if (inst == None)
-            return self;
-        else
-            return boxInstanceMethod(inst, self, self->type);
-    }
-
-    static Box* __call__(BoxedMethodDescriptor* self, Box* obj, BoxedTuple* varargs, Box** _args);
-    static Box* callInternal(BoxedFunctionBase* f, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1,
-                             Box* arg2, Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names);
-
-    static void gcHandler(GCVisitor* v, Box* _o) {
-        assert(_o->cls == method_cls);
-        BoxedMethodDescriptor* o = static_cast<BoxedMethodDescriptor*>(_o);
-
-        boxGCHandler(v, o);
-        v->visit(o->type);
-    }
-};
-
 PyObject* convert_3way_to_object(int op, int c) noexcept;
 int default_3way_compare(PyObject* v, PyObject* w);
 

src/runtime/capi.cpp

@@ -53,47 +53,6 @@ extern "C" {
 int Py_Py3kWarningFlag;
 
 BoxedClass* capifunc_cls;
-BoxedClass* wrapperdescr_cls, *wrapperobject_cls;
-}
-
-Box* BoxedWrapperDescriptor::__get__(BoxedWrapperDescriptor* self, Box* inst, Box* owner) {
-    RELEASE_ASSERT(self->cls == wrapperdescr_cls, "");
-
-    if (inst == None)
-        return self;
-
-    if (!isSubclass(inst->cls, self->type))
-        raiseExcHelper(TypeError, "Descriptor '' for '%s' objects doesn't apply to '%s' object",
-                       getFullNameOfClass(self->type).c_str(), getFullTypeName(inst).c_str());
-
-    return new BoxedWrapperObject(self, inst);
-}
-
-Box* BoxedWrapperDescriptor::descr_get(Box* _self, Box* inst, Box* owner) noexcept {
-    RELEASE_ASSERT(_self->cls == wrapperdescr_cls, "");
-    BoxedWrapperDescriptor* self = static_cast<BoxedWrapperDescriptor*>(_self);
-
-    if (inst == None)
-        return self;
-
-    if (!isSubclass(inst->cls, self->type))
-        PyErr_Format(TypeError, "Descriptor '' for '%s' objects doesn't apply to '%s' object",
-                     getFullNameOfClass(self->type).c_str(), getFullTypeName(inst).c_str());
-
-    return new BoxedWrapperObject(self, inst);
-}
-
-Box* BoxedWrapperDescriptor::__call__(BoxedWrapperDescriptor* descr, PyObject* self, BoxedTuple* args, Box** _args) {
-    RELEASE_ASSERT(descr->cls == wrapperdescr_cls, "");
-
-    BoxedDict* kw = static_cast<BoxedDict*>(_args[0]);
-
-    if (!isSubclass(self->cls, descr->type))
-        raiseExcHelper(TypeError, "descriptor '' requires a '%s' object but received a '%s'",
-                       getFullNameOfClass(descr->type).c_str(), getFullTypeName(self).c_str());
-
-    auto wrapper = new BoxedWrapperObject(descr, self);
-    return BoxedWrapperObject::__call__(wrapper, args, kw);
 }
 
 extern "C" void _PyErr_BadInternalCall(const char* filename, int lineno) noexcept {
@@ -1645,21 +1604,6 @@ Box* BoxedCApiFunction::callInternal(BoxedFunctionBase* func, CallRewriteArgs* r
     return r;
 }
 
-static Box* methodGetDoc(Box* b, void*) {
-    assert(b->cls == method_cls);
-    const char* s = static_cast<BoxedMethodDescriptor*>(b)->method->ml_doc;
-    if (s)
-        return boxString(s);
-    return None;
-}
-
-static Box* wrapperdescrGetDoc(Box* b, void*) {
-    assert(b->cls == wrapperdescr_cls);
-    auto s = static_cast<BoxedWrapperDescriptor*>(b)->wrapper->doc;
-    assert(s.size());
-    return boxString(s);
-}
-
 /* extension modules might be compiled with GC support so these
    functions must always be available */
 
@@ -1719,10 +1663,6 @@ extern "C" void _Py_FatalError(const char* fmt, const char* function, const char
     abort();
 }
 
-extern "C" PyObject* PyClassMethod_New(PyObject* callable) noexcept {
-    return new BoxedClassmethod(callable);
-}
-
 void setupCAPI() {
     capifunc_cls->giveAttr("__repr__",
                            new BoxedFunction(boxRTFunction((void*)BoxedCApiFunction::__repr__, UNKNOWN, 1)));
@@ -1736,27 +1676,6 @@ void setupCAPI() {
         "__module__", new BoxedMemberDescriptor(BoxedMemberDescriptor::OBJECT, offsetof(BoxedCApiFunction, module)));
 
     capifunc_cls->freeze();
-
-    method_cls->giveAttr("__get__",
-                         new BoxedFunction(boxRTFunction((void*)BoxedMethodDescriptor::__get__, UNKNOWN, 3)));
-    CLFunction* method_call_cl = boxRTFunction((void*)BoxedMethodDescriptor::__call__, UNKNOWN, 2, 0, true, true);
-    method_call_cl->internal_callable = BoxedMethodDescriptor::callInternal;
-    method_cls->giveAttr("__call__", new BoxedFunction(method_call_cl));
-    method_cls->giveAttr("__doc__", new (pyston_getset_cls) BoxedGetsetDescriptor(methodGetDoc, NULL, NULL));
-    method_cls->freeze();
-
-    wrapperdescr_cls->giveAttr("__get__",
-                               new BoxedFunction(boxRTFunction((void*)BoxedWrapperDescriptor::__get__, UNKNOWN, 3)));
-    wrapperdescr_cls->giveAttr("__call__", new BoxedFunction(boxRTFunction((void*)BoxedWrapperDescriptor::__call__,
-                                                                           UNKNOWN, 2, 0, true, true)));
-    wrapperdescr_cls->giveAttr("__doc__",
-                               new (pyston_getset_cls) BoxedGetsetDescriptor(wrapperdescrGetDoc, NULL, NULL));
-    wrapperdescr_cls->freeze();
-    wrapperdescr_cls->tp_descr_get = BoxedWrapperDescriptor::descr_get;
-
-    wrapperobject_cls->giveAttr(
-        "__call__", new BoxedFunction(boxRTFunction((void*)BoxedWrapperObject::__call__, UNKNOWN, 1, 0, true, true)));
-    wrapperobject_cls->freeze();
 }
 
 void teardownCAPI() {

src/runtime/types.h

@@ -88,7 +88,8 @@ extern BoxedClass* object_cls, *type_cls, *bool_cls, *int_cls, *long_cls, *float
     *none_cls, *instancemethod_cls, *list_cls, *slice_cls, *module_cls, *dict_cls, *tuple_cls, *file_cls,
     *enumerate_cls, *xrange_cls, *member_descriptor_cls, *method_cls, *closure_cls, *generator_cls, *complex_cls,
     *basestring_cls, *property_cls, *staticmethod_cls, *classmethod_cls, *attrwrapper_cls, *pyston_getset_cls,
-    *capi_getset_cls, *builtin_function_or_method_cls, *set_cls, *frozenset_cls, *code_cls, *frame_cls;
+    *capi_getset_cls, *builtin_function_or_method_cls, *set_cls, *frozenset_cls, *code_cls, *frame_cls, *capifunc_cls,
+    *wrapperdescr_cls, *wrapperobject_cls;
 }
 #define unicode_cls (&PyUnicode_Type)
 #define memoryview_cls (&PyMemoryView_Type)
@@ -869,6 +870,62 @@ public:
     DEFAULT_CLASS(generator_cls);
 };
 
+struct wrapper_def {
+    const llvm::StringRef name;
+    int offset;
+    void* function;      // "generic" handler that gets put in the tp_* slot which proxies to the python version
+    wrapperfunc wrapper; // "wrapper" that ends up getting called by the Python-visible WrapperDescr
+    const llvm::StringRef doc;
+    int flags;
+    // exists in CPython: PyObject *name_strobj
+};
+
+class BoxedWrapperDescriptor : public Box {
+public:
+    const wrapper_def* wrapper;
+    BoxedClass* type;
+    void* wrapped;
+    BoxedWrapperDescriptor(const wrapper_def* wrapper, BoxedClass* type, void* wrapped)
+        : wrapper(wrapper), type(type), wrapped(wrapped) {}
+
+    DEFAULT_CLASS(wrapperdescr_cls);
+
+    static Box* __get__(BoxedWrapperDescriptor* self, Box* inst, Box* owner);
+    static Box* descr_get(Box* self, Box* inst, Box* owner) noexcept;
+    static Box* __call__(BoxedWrapperDescriptor* descr, PyObject* self, BoxedTuple* args, Box** _args);
+
+    static void gcHandler(GCVisitor* v, Box* _o);
+};
+
+class BoxedWrapperObject : public Box {
+public:
+    BoxedWrapperDescriptor* descr;
+    Box* obj;
+
+    BoxedWrapperObject(BoxedWrapperDescriptor* descr, Box* obj) : descr(descr), obj(obj) {}
+
+    DEFAULT_CLASS(wrapperobject_cls);
+
+    static Box* __call__(BoxedWrapperObject* self, Box* args, Box* kwds);
+    static void gcHandler(GCVisitor* v, Box* _o);
+};
+
+class BoxedMethodDescriptor : public Box {
+public:
+    PyMethodDef* method;
+    BoxedClass* type;
+
+    BoxedMethodDescriptor(PyMethodDef* method, BoxedClass* type) : method(method), type(type) {}
+
+    DEFAULT_CLASS(method_cls);
+
+    static Box* __get__(BoxedMethodDescriptor* self, Box* inst, Box* owner);
+    static Box* __call__(BoxedMethodDescriptor* self, Box* obj, BoxedTuple* varargs, Box** _args);
+    static Box* callInternal(BoxedFunctionBase* f, CallRewriteArgs* rewrite_args, ArgPassSpec argspec, Box* arg1,
+                             Box* arg2, Box* arg3, Box** args, const std::vector<BoxedString*>* keyword_names);
+    static void gcHandler(GCVisitor* v, Box* _o);
+};
+
 extern "C" void boxGCHandler(GCVisitor* v, Box* b);
 
 Box* objectNewNoArgs(BoxedClass* cls);