some misc fixing

src/runtime/capi.cpp

@@ -583,10 +583,12 @@ extern "C" int PyObject_IsTrue(PyObject* o) noexcept {
     }
 }
 
-
 extern "C" int PyObject_Not(PyObject* o) noexcept {
-    fatalOrError(PyExc_NotImplementedError, "unimplemented");
-    return -1;
+    int res;
+    res = PyObject_IsTrue(o);
+    if (res < 0)
+        return res;
+    return res == 0;
 }
 
 extern "C" PyObject* PyObject_Call(PyObject* callable_object, PyObject* args, PyObject* kw) noexcept {

src/runtime/objmodel.cpp

@@ -4160,7 +4160,7 @@ Box* callCLFunc(FunctionMetadata* md, CallRewriteArgs* rewrite_args, int num_out
         ASSERT(chosen_cf->spec->rtn_type->isFitBy(r->cls), "%s (%p) was supposed to return %s, but gave a %s",
                g.func_addr_registry.getFuncNameAtAddress(chosen_cf->code, true, NULL).c_str(), chosen_cf->code,
                chosen_cf->spec->rtn_type->debugName().c_str(), r->cls->tp_name);
-        ASSERT(!PyErr_Occurred(), "%p", chosen_cf->code);
+        ASSERT(!PyErr_Occurred() || S == CAPI, "%p", chosen_cf->code);
     }
 
     return r;

src/runtime/str.cpp

@@ -1226,9 +1226,13 @@ Box* str_richcompare(Box* lhs, Box* rhs, int op) {
 #define JUST_RIGHT 1
 #define JUST_CENTER 2
 static Box* pad(BoxedString* self, Box* width, Box* fillchar, int justType) {
-    assert(width->cls == int_cls);
-    assert(PyString_Check(fillchar));
-    assert(static_cast<BoxedString*>(fillchar)->size() == 1);
+    if (!PyInt_Check(width)) {
+        raiseExcHelper(TypeError, "an integer is required");
+    }
+    if (!PyString_Check(fillchar) || static_cast<BoxedString*>(fillchar)->size() != 1) {
+        raiseExcHelper(TypeError, "must be char, not %s", fillchar->cls->tp_name);
+    }
+
     int64_t curWidth = self->size();
     int64_t targetWidth = static_cast<BoxedInt*>(width)->n;
 
@@ -1628,11 +1632,11 @@ extern "C" Box* strNonzero(BoxedString* self) {
     return boxBool(self->size() != 0);
 }
 
-extern "C" Box* strNew(BoxedClass* cls, Box* obj) {
+template <ExceptionStyle S> Box* strNew(BoxedClass* cls, Box* obj) {
     assert(isSubclass(cls, str_cls));
 
     if (cls != str_cls) {
-        Box* tmp = strNew(str_cls, obj);
+        Box* tmp = strNew<S>(str_cls, obj);
         assert(PyString_Check(tmp));
         BoxedString* tmp_s = static_cast<BoxedString*>(tmp);
 
@@ -1640,10 +1644,30 @@ extern "C" Box* strNew(BoxedClass* cls, Box* obj) {
     }
 
     Box* r = PyObject_Str(obj);
+    if (S == CAPI)
+        return r;
+    else {
         if (!r)
             throwCAPIException();
         assert(PyString_Check(r));
         return r;
+    }
+}
+
+// Roughly analogous to CPython's string_new.
+// The arguments need to be unpacked from args and kwds.
+static Box* strNewPacked(BoxedClass* type, Box* args, Box* kwds) noexcept {
+    PyObject* x = NULL;
+    static char* kwlist[2] = { NULL, NULL };
+    kwlist[0] = const_cast<char*>("object");
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:str", kwlist, &x))
+        return NULL;
+
+    if (x == NULL)
+        return PyString_FromString("");
+
+    return strNew<CAPI>(type, x);
 }
 
 extern "C" Box* basestringNew(BoxedClass* cls, Box* args, Box* kwargs) {
@@ -2898,8 +2922,9 @@ void setupStr() {
         str_cls->giveAttr(md.ml_name, new BoxedMethodDescriptor(&md, str_cls));
     }
 
-    str_cls->giveAttr("__new__", new BoxedFunction(FunctionMetadata::create((void*)strNew, UNKNOWN, 2, false, false),
-                                                   { EmptyString }));
+    auto str_new = FunctionMetadata::create((void*)strNew<CXX>, UNKNOWN, 2, false, false, ParamNames::empty(), CXX);
+    str_new->addVersion((void*)strNew<CAPI>, UNKNOWN, CAPI);
+    str_cls->giveAttr("__new__", new BoxedFunction(str_new, { EmptyString }));
 
     add_operators(str_cls);
     str_cls->freeze();
@@ -2912,6 +2937,7 @@ void setupStr() {
     str_cls->tp_as_sequence->sq_item = (ssizeargfunc)string_item;
     str_cls->tp_as_sequence->sq_slice = str_slice;
     str_cls->tp_as_sequence->sq_contains = (objobjproc)string_contains;
+    str_cls->tp_new = (newfunc)strNewPacked;
 
     basestring_cls->giveAttr("__doc__",
                              boxString("Type basestring cannot be instantiated; it is the base for str and unicode."));

src/runtime/tuple.cpp

@@ -156,9 +156,11 @@ template <ExceptionStyle S> Box* tupleGetitem(BoxedTuple* self, Box* slice) {
         raiseExcHelper(TypeError, "tuple indices must be integers, not %s", getTypeName(slice));
 }
 
+// TODO: duplicate with tupleconcat?
 Box* tupleAdd(BoxedTuple* self, Box* rhs) {
     if (!PyTuple_Check(rhs)) {
-        return NotImplemented;
+        raiseExcHelper(TypeError, "can only concatenate tuple (not \"%.200s\") to tuple", getTypeName(rhs));
+        return NULL;
     }
 
     BoxedTuple* _rhs = static_cast<BoxedTuple*>(rhs);

src/runtime/types.cpp

@@ -3568,6 +3568,9 @@ static Box* getsetGet(Box* self, Box* obj, Box* type) {
         return self;
 
     BoxedGetsetDescriptor* getset_descr = static_cast<BoxedGetsetDescriptor*>(self);
+
+    assert(getset_descr->get != NULL);
+
     if (isSubclass(self->cls, pyston_getset_cls)) {
         return getset_descr->get(obj, getset_descr->closure);
     } else {
@@ -3583,6 +3586,10 @@ static Box* getsetSet(Box* self, Box* obj, Box* val) {
     assert(obj != NULL && obj != None);
 
     BoxedGetsetDescriptor* getset_descr = static_cast<BoxedGetsetDescriptor*>(self);
+
+    if (getset_descr->set == NULL)
+        return None;
+
     if (isSubclass(self->cls, pyston_getset_cls)) {
         getset_descr->set(obj, val, getset_descr->closure);
         return None;
@@ -3598,6 +3605,10 @@ static Box* getsetDelete(Box* self, Box* obj) {
     assert(obj != NULL && obj != None);
 
     BoxedGetsetDescriptor* getset_descr = static_cast<BoxedGetsetDescriptor*>(self);
+
+    if (getset_descr->set == NULL)
+        return None;
+
     if (isSubclass(self->cls, pyston_getset_cls)) {
         getset_descr->set(obj, NULL, getset_descr->closure);
         return None;

src/runtime/types.h

@@ -429,7 +429,7 @@ public:
         assert(str_cls->is_pyston_class);
         assert(str_cls->attrs_offset == 0);
 
-        void* mem = gc_alloc(sizeof(BoxedString) + 1 + nitems, gc::GCKind::PYTHON);
+        void* mem = gc_alloc(sizeof(BoxedString) + 2 + nitems, gc::GCKind::PYTHON);
         assert(mem);
 
         BoxVar* rtn = static_cast<BoxVar*>(mem);