Merge branch 'django_dependencies'

Makefile

@@ -293,7 +293,7 @@ STDLIB_RELEASE_OBJS := stdlib.release.bc.o
 ASM_SRCS := $(wildcard src/runtime/*.S)
 
 STDMODULE_SRCS := errnomodule.c shamodule.c sha256module.c sha512module.c _math.c mathmodule.c md5.c md5module.c _randommodule.c _sre.c operator.c binascii.c pwdmodule.c posixmodule.c _struct.c datetimemodule.c _functoolsmodule.c _collectionsmodule.c itertoolsmodule.c resource.c signalmodule.c selectmodule.c fcntlmodule.c timemodule.c arraymodule.c zlibmodule.c _codecsmodule.c socketmodule.c unicodedata.c _weakref.c cStringIO.c _io/bufferedio.c _io/bytesio.c _io/fileio.c _io/iobase.c _io/_iomodule.c _io/stringio.c _io/textio.c $(EXTRA_STDMODULE_SRCS)
-STDOBJECT_SRCS := structseq.c capsule.c stringobject.c exceptions.c unicodeobject.c unicodectype.c bytearrayobject.c bytes_methods.c weakrefobject.c memoryobject.c $(EXTRA_STDOBJECT_SRCS)
+STDOBJECT_SRCS := structseq.c capsule.c stringobject.c exceptions.c unicodeobject.c unicodectype.c bytearrayobject.c bytes_methods.c weakrefobject.c memoryobject.c iterobject.c $(EXTRA_STDOBJECT_SRCS)
 STDPYTHON_SRCS := pyctype.c getargs.c formatter_string.c pystrtod.c dtoa.c formatter_unicode.c structmember.c $(EXTRA_STDPYTHON_SRCS)
 FROM_CPYTHON_SRCS := $(addprefix from_cpython/Modules/,$(STDMODULE_SRCS)) $(addprefix from_cpython/Objects/,$(STDOBJECT_SRCS)) $(addprefix from_cpython/Python/,$(STDPYTHON_SRCS))
 

from_cpython/CMakeLists.txt

@@ -18,7 +18,7 @@ add_custom_target(copy_stdlib ALL DEPENDS ${STDLIB_TARGETS})
 file(GLOB_RECURSE STDMODULE_SRCS Modules errnomodule.c shamodule.c sha256module.c sha512module.c _math.c mathmodule.c md5.c md5module.c _randommodule.c _sre.c operator.c binascii.c pwdmodule.c posixmodule.c _struct.c datetimemodule.c _functoolsmodule.c _collectionsmodule.c itertoolsmodule.c resource.c signalmodule.c selectmodule.c fcntlmodule.c timemodule.c arraymodule.c zlibmodule.c _codecsmodule.c socketmodule.c unicodedata.c _weakref.c cStringIO.c bufferedio.c bytesio.c fileio.c iobase.c _iomodule.c stringio.c textio.c)
 
 # compile specified files in from_cpython/Objects
-file(GLOB_RECURSE STDOBJECT_SRCS Objects structseq.c capsule.c stringobject.c exceptions.c unicodeobject.c unicodectype.c bytearrayobject.c bytes_methods.c weakrefobject.c memoryobject.c)
+file(GLOB_RECURSE STDOBJECT_SRCS Objects structseq.c capsule.c stringobject.c exceptions.c unicodeobject.c unicodectype.c bytearrayobject.c bytes_methods.c weakrefobject.c memoryobject.c iterobject.c)
 
 # compile specified files in from_cpython/Python
 file(GLOB_RECURSE STDPYTHON_SRCS Python getargs.c pyctype.c formatter_string.c pystrtod.c dtoa.c formatter_unicode.c structmember.c)

from_cpython/Include/iterobject.h

@@ -14,8 +14,7 @@ extern "C" {
 
 PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *) PYSTON_NOEXCEPT;
 
-// Pyston change: this is no longer a static object
-//PyAPI_DATA(PyTypeObject) PyCallIter_Type;
+PyAPI_DATA(PyTypeObject) PyCallIter_Type;
 
 #define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type)
 

from_cpython/Objects/iterobject.c

+// This file is originally from CPython 2.7, with modifications for Pyston
+
+// (actually it's just a subset of the CPython version)
+
+#include "Python.h"
+
+extern PyTypeObject PyCallIter_Type;
+typedef struct {
+    PyObject_HEAD
+    PyObject *it_callable; /* Set to NULL when iterator is exhausted */
+    PyObject *it_sentinel; /* Set to NULL when iterator is exhausted */
+} calliterobject;
+
+PyObject *
+PyCallIter_New(PyObject *callable, PyObject *sentinel)
+{
+    calliterobject *it;
+    it = PyObject_GC_New(calliterobject, &PyCallIter_Type);
+    if (it == NULL)
+        return NULL;
+    Py_INCREF(callable);
+    it->it_callable = callable;
+    Py_INCREF(sentinel);
+    it->it_sentinel = sentinel;
+    _PyObject_GC_TRACK(it);
+    return (PyObject *)it;
+}
+static void
+calliter_dealloc(calliterobject *it)
+{
+    _PyObject_GC_UNTRACK(it);
+    Py_XDECREF(it->it_callable);
+    Py_XDECREF(it->it_sentinel);
+    PyObject_GC_Del(it);
+}
+
+static int
+calliter_traverse(calliterobject *it, visitproc visit, void *arg)
+{
+    Py_VISIT(it->it_callable);
+    Py_VISIT(it->it_sentinel);
+    return 0;
+}
+
+static PyObject *
+calliter_iternext(calliterobject *it)
+{
+    if (it->it_callable != NULL) {
+        PyObject *args = PyTuple_New(0);
+        PyObject *result;
+        if (args == NULL)
+            return NULL;
+        result = PyObject_Call(it->it_callable, args, NULL);
+        Py_DECREF(args);
+        if (result != NULL) {
+            int ok;
+            ok = PyObject_RichCompareBool(result,
+                                          it->it_sentinel,
+                                          Py_EQ);
+            if (ok == 0)
+                return result; /* Common case, fast path */
+            Py_DECREF(result);
+            if (ok > 0) {
+                Py_CLEAR(it->it_callable);
+                Py_CLEAR(it->it_sentinel);
+            }
+        }
+        else if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+            PyErr_Clear();
+            Py_CLEAR(it->it_callable);
+            Py_CLEAR(it->it_sentinel);
+        }
+    }
+    return NULL;
+}
+
+PyTypeObject PyCallIter_Type = {
+    // Pyston change:
+    PyVarObject_HEAD_INIT(NULL /* &PyType_Type */, 0)
+    "callable-iterator",                        /* tp_name */
+    sizeof(calliterobject),                     /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    /* methods */
+    (destructor)calliter_dealloc,               /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    PyObject_GenericGetAttr,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)calliter_traverse,            /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    PyObject_SelfIter,                          /* tp_iter */
+    (iternextfunc)calliter_iternext,            /* tp_iternext */
+    0,                                          /* tp_methods */
+};
+

src/analysis/scoping_analysis.cpp

@@ -407,6 +407,8 @@ public:
             for (AST_comprehension* c : node->generators) {
                 if (!first)
                     c->iter->accept(this);
+                for (auto i : c->ifs)
+                    i->accept(this);
                 c->target->accept(this);
                 first = false;
             }

src/capi/abstract.cpp

@@ -135,7 +135,9 @@ extern "C" void PyBuffer_Release(Py_buffer* view) noexcept {
 
     PyObject* obj = view->obj;
     if (obj) {
-        assert(obj->cls == str_cls);
+        // This is a Pyston assert
+        assert(isSubclass(obj->cls, str_cls));
+
         if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer)
             Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view);
         Py_XDECREF(obj);

src/jit.cpp

@@ -45,23 +45,28 @@
 #error
 #endif
 
-using namespace pyston;
+namespace pyston {
 
 // returns true iff we got a request to exit, i.e. SystemExit, placing the
 // return code in `*retcode`. does not touch `*retcode* if it returns false.
 static bool handle_toplevel_exn(const ExcInfo& e, int* retcode) {
     if (e.matches(SystemExit)) {
         Box* code = e.value->getattr("code");
-        *retcode = 1;
-        if (code && isSubclass(code->cls, pyston::int_cls))
+
+        if (!code || code == None)
+            *retcode = 0;
+        else if (isSubclass(code->cls, int_cls))
             *retcode = static_cast<BoxedInt*>(code)->n;
+        else
+            *retcode = 1;
+
         return true;
     }
     e.printExcAndTraceback();
     return false;
 }
 
-int main(int argc, char** argv) {
+static int main(int argc, char** argv) {
     Timer _t("for jit startup");
     // llvm::sys::PrintStackTraceOnErrorSignal();
     // llvm::PrettyStackTraceProgram X(argc, argv);
@@ -259,3 +264,9 @@ int main(int argc, char** argv) {
 
     return rtncode;
 }
+
+} // namespace pyston
+
+int main(int argc, char** argv) {
+    return pyston::main(argc, argv);
+}

src/runtime/capi.cpp

@@ -852,10 +852,6 @@ extern "C" PyObject* PyImport_Import(PyObject* module_name) noexcept {
 }
 
 
-extern "C" PyObject* PyCallIter_New(PyObject* callable, PyObject* sentinel) noexcept {
-    Py_FatalError("unimplemented");
-}
-
 extern "C" void* PyObject_Malloc(size_t sz) noexcept {
     return gc_compat_malloc(sz);
 }

src/runtime/dict.h

@@ -57,6 +57,7 @@ public:
 Box* dictViewKeysIter(Box* self);
 Box* dictViewValuesIter(Box* self);
 Box* dictViewItemsIter(Box* self);
+void dictMerge(BoxedDict* self, Box* other);
 }
 
 #endif

src/runtime/file.cpp

@@ -1055,14 +1055,27 @@ extern "C" size_t Py_UniversalNewlineFread(char* buf, size_t n, FILE* stream, Py
     return dst - buf;
 }
 
+static PyObject* file_isatty(BoxedFile* f) noexcept {
+    long res;
+    if (f->f_fp == NULL)
+        return err_closed();
+    FILE_BEGIN_ALLOW_THREADS(f)
+    res = isatty((int)fileno(f->f_fp));
+    FILE_END_ALLOW_THREADS(f)
+    return PyBool_FromLong(res);
+}
+
 PyDoc_STRVAR(readlines_doc, "readlines([size]) -> list of strings, each a line from the file.\n"
                             "\n"
                             "Call readline() repeatedly and return a list of the lines so read.\n"
                             "The optional size argument, if given, is an approximate bound on the\n"
                             "total number of bytes in the lines returned.");
 
+PyDoc_STRVAR(isatty_doc, "isatty() -> true or false.  True if the file is connected to a tty device.");
+
 PyMethodDef file_methods[] = {
     { "readlines", (PyCFunction)file_readlines, METH_VARARGS, readlines_doc },
+    { "isatty", (PyCFunction)file_isatty, METH_NOARGS, isatty_doc },
 };
 
 void fileDestructor(Box* b) {

src/runtime/float.cpp

@@ -87,6 +87,8 @@ extern "C" Box* floatAdd(BoxedFloat* lhs, Box* rhs) {
         return floatAddInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatAddFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(lhs->d + PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -112,6 +114,8 @@ extern "C" Box* floatDiv(BoxedFloat* lhs, Box* rhs) {
         return floatDivInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(lhs->d / PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -123,6 +127,8 @@ extern "C" Box* floatTruediv(BoxedFloat* lhs, Box* rhs) {
         return floatDivInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(lhs->d / PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -148,6 +154,8 @@ extern "C" Box* floatRDiv(BoxedFloat* lhs, Box* rhs) {
         return floatRDivInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatRDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(PyLong_AsDouble(rhs) / lhs->d);
     } else {
         return NotImplemented;
     }
@@ -196,6 +204,8 @@ extern "C" Box* floatEq(BoxedFloat* lhs, Box* rhs) {
         return floatEqInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatEqFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d == PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -219,6 +229,8 @@ extern "C" Box* floatNe(BoxedFloat* lhs, Box* rhs) {
         return floatNeInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatNeFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d != PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -242,6 +254,8 @@ extern "C" Box* floatLt(BoxedFloat* lhs, Box* rhs) {
         return floatLtInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatLtFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d < PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -265,6 +279,8 @@ extern "C" Box* floatLe(BoxedFloat* lhs, Box* rhs) {
         return floatLeInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatLeFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d <= PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -288,6 +304,8 @@ extern "C" Box* floatGt(BoxedFloat* lhs, Box* rhs) {
         return floatGtInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatGtFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d > PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -311,6 +329,8 @@ extern "C" Box* floatGe(BoxedFloat* lhs, Box* rhs) {
         return floatGeInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatGeFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxBool(lhs->d >= PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -334,6 +354,8 @@ extern "C" Box* floatMod(BoxedFloat* lhs, Box* rhs) {
         return floatModInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatModFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(mod_float_float(lhs->d, PyLong_AsDouble(rhs)));
     } else {
         return NotImplemented;
     }
@@ -357,6 +379,8 @@ extern "C" Box* floatRMod(BoxedFloat* lhs, Box* rhs) {
         return floatRModInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatRModFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(mod_float_float(PyLong_AsDouble(rhs), lhs->d));
     } else {
         return NotImplemented;
     }
@@ -380,6 +404,8 @@ extern "C" Box* floatPow(BoxedFloat* lhs, Box* rhs) {
         return floatPowInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatPowFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(pow(lhs->d, PyLong_AsDouble(rhs)));
     } else {
         return NotImplemented;
     }
@@ -403,6 +429,8 @@ extern "C" Box* floatMul(BoxedFloat* lhs, Box* rhs) {
         return floatMulInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatMulFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(lhs->d * PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -426,6 +454,8 @@ extern "C" Box* floatSub(BoxedFloat* lhs, Box* rhs) {
         return floatSubInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatSubFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(lhs->d - PyLong_AsDouble(rhs));
     } else {
         return NotImplemented;
     }
@@ -449,6 +479,8 @@ extern "C" Box* floatRSub(BoxedFloat* lhs, Box* rhs) {
         return floatRSubInt(lhs, static_cast<BoxedInt*>(rhs));
     } else if (rhs->cls == float_cls) {
         return floatRSubFloat(lhs, static_cast<BoxedFloat*>(rhs));
+    } else if (rhs->cls == long_cls) {
+        return boxFloat(PyLong_AsDouble(rhs) - lhs->d);
     } else {
         return NotImplemented;
     }
@@ -545,6 +577,9 @@ std::string floatFmt(double x, int precision, char code) {
 }
 
 BoxedFloat* _floatNew(Box* a) {
+    // FIXME CPython uses PyUnicode_EncodeDecimal:
+    a = coerceUnicodeToStr(a);
+
     if (a->cls == float_cls) {
         return static_cast<BoxedFloat*>(a);
     } else if (isSubclass(a->cls, float_cls)) {

src/runtime/objmodel.cpp

@@ -41,6 +41,7 @@
 #include "gc/heap.h"
 #include "runtime/capi.h"
 #include "runtime/classobj.h"
+#include "runtime/dict.h"
 #include "runtime/file.h"
 #include "runtime/float.h"
 #include "runtime/generator.h"
@@ -303,6 +304,9 @@ BoxedClass::BoxedClass(BoxedClass* base, gcvisit_func gc_visit, int attrs_offset
     tp_flags |= Py_TPFLAGS_HAVE_GC;
     tp_flags |= Py_TPFLAGS_HAVE_WEAKREFS;
 
+    if (base && (base->tp_flags & Py_TPFLAGS_HAVE_NEWBUFFER))
+        tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
+
     tp_base = base;
 
     if (tp_base) {
@@ -1940,7 +1944,7 @@ extern "C" BoxedInt* hash(Box* obj) {
     Box* hash = getclsattr_internal(obj, "__hash__", NULL);
 
     if (hash == NULL) {
-        ASSERT(isUserDefined(obj->cls), "%s.__hash__", getTypeName(obj));
+        ASSERT(isUserDefined(obj->cls) || obj->cls == function_cls, "%s.__hash__", getTypeName(obj));
         // TODO not the best way to handle this...
         return static_cast<BoxedInt*>(boxInt((i64)obj));
     }
@@ -2693,7 +2697,13 @@ Box* callFunc(BoxedFunctionBase* func, CallRewriteArgs* rewrite_args, ArgPassSpe
 
         Box* kwargs
             = getArg(argspec.num_args + argspec.num_keywords + (argspec.has_starargs ? 1 : 0), arg1, arg2, arg3, args);
-        RELEASE_ASSERT(kwargs->cls == dict_cls, "haven't implemented this for non-dicts");
+
+        if (!isSubclass(kwargs->cls, dict_cls)) {
+            BoxedDict* d = new BoxedDict();
+            dictMerge(d, kwargs);
+            kwargs = d;
+        }
+        assert(isSubclass(kwargs->cls, dict_cls));
         BoxedDict* d_kwargs = static_cast<BoxedDict*>(kwargs);
 
         for (auto& p : d_kwargs->d) {
@@ -3288,6 +3298,7 @@ Box* compareInternal(Box* lhs, Box* rhs, int op_type, CompareRewriteArgs* rewrit
 #ifndef NDEBUG
     if ((lhs->cls == int_cls || lhs->cls == float_cls || lhs->cls == long_cls)
         && (rhs->cls == int_cls || rhs->cls == float_cls || rhs->cls == long_cls)) {
+        printf("\n%s %s %s\n", lhs->cls->tp_name, op_name.c_str(), rhs->cls->tp_name);
         Py_FatalError("missing comparison between these classes");
     }
 #endif

src/runtime/types.cpp

@@ -1159,10 +1159,9 @@ Box* objectStr(Box* obj) {
 }
 
 static Box* typeName(Box* b, void*) {
-    assert(b->cls == type_cls);
+    RELEASE_ASSERT(isSubclass(b->cls, type_cls), "");
     BoxedClass* type = static_cast<BoxedClass*>(b);
 
-    // TODO is this predicate right?
     if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
         BoxedHeapClass* et = static_cast<BoxedHeapClass*>(type);
         return et->ht_name;
@@ -1321,6 +1320,8 @@ void setupRuntime() {
     tuple_cls->finishInitialization();
     list_cls->finishInitialization();
 
+    str_cls->tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
+
 
 
     module_cls = BoxedHeapClass::create(type_cls, object_cls, NULL, offsetof(BoxedModule, attrs), 0,
@@ -1516,6 +1517,7 @@ void setupRuntime() {
     setupPyston();
 
     PyType_Ready(&PyCapsule_Type);
+    PyType_Ready(&PyCallIter_Type);
 
     initerrno();
     init_sha();

test/tests/genexps.py

@@ -15,3 +15,10 @@ def f2():
     print list(g2)
 f2()
 
+# Make sure that the 'ifs' part gets scoped properly
+def f3():
+    b = True
+    print list(x for x in range(5) if b)
+    print list(x for x in range(5) if [b for b in xrange(4)])
+    print b
+print f3()

test/tests/gzip_test.py

-# allow-warning: import level 0 will be treated as -1
 import gzip
 import io
 

test/tests/io_test.py

-# allow-warning: import level 0 will be treated as -1
 import io
 filename = "io_test_.txt"
 

test/tests/kwargs_protocol.py

-# expected: fail
-# - not supported yet
-
 class C(object):
     def __len__(self):
         print "__len__"
@@ -26,3 +23,20 @@ def f(a, b, c):
     print a, b, c
 
 f(**C())
+
+
+class MyDict(dict):
+    pass
+
+d = MyDict(a=1, b=2, c=3)
+print f(**d)
+
+
+# Django does this:
+class C(object):
+    pass
+c = C()
+c.a = 1
+c.b = 3
+c.c = 7
+print f(**c.__dict__)

test/tests/long.py

@@ -8,7 +8,7 @@ for i in xrange(150):
     print t, repr(t)
 
 def test(a, b):
-    print a, b
+    print repr(a), repr(b)
     print a + b, b + a, a.__add__(b), b.__add__(a)
     print a - b, b - a, a.__sub__(b), b.__sub__(a)
     print a * b, b * a, a.__mul__(b), b.__mul__(a)
@@ -26,6 +26,9 @@ for a in [-5, -1, 1, 5, -2L, -1L, 1L, 2L]:
     for b in [-5, -1, 1, 5, -2L, -1L, 1L, 2L]:
         test(a, b)
 
+test(1L, 2.0)
+test(3.0, 2L)
+
 print (2L).__rdiv__(-1)
 print (2L).__rdiv__(-1L)
 print (-2L).__rdiv__(1L)

test/tests/optparse_test.py

-# allow-warning: import level 0 will be treated as -1
 # Simple optparse test, taken from the optparse.py docstring:
 
 from optparse import OptionParser

test/tests/pickle_test.py

-# allow-warning: import level 0 will be treated as -1
-
 import pickle
 
 l = [[], (123,)]

test/tests/prevent_nonascii_attrs.py

-# allow-warning: import level 0 will be treated as -1
 # skip-if: '-x' in EXTRA_JIT_ARGS
 
 def f(a):

test/tests/str_encode_decode.py

-# allow-warning: import level 0 will be treated as -1!
 def test(string, encoding):
  s = string.encode(encoding)
  print encoding, s

test/tests/str_functions.py

@@ -139,3 +139,6 @@ except:
 
 print repr("hello\tworld\t".expandtabs())
 print repr("hello\tworld\t".expandtabs(12))
+
+print "hello world".startswith(("x", "h"))
+print "hello world".endswith(("x", "h"))

test/tests/str_subclassing.py

+class MyStr(str):
+    pass
+
+s = MyStr(1)
+print repr(s)
+
+import sys
+sys.stdout.write(s)

test/tests/sys_exit_none.py

+# no-collect-stats
+
+import sys
+sys.exit(None)

test/tests/unicode_test.py

 # skip-if: '-x' in EXTRA_JIT_ARGS
-# allow-warning: import level 0 will be treated as -1
 
 print repr(unicode())
 print repr(unicode('hello world'))
@@ -81,3 +80,12 @@ f(**{'a':2})
 f(**{u'a':3})
 
 print repr('%s' % u'') # this gives a unicode object!
+
+print repr('hello world'.replace(u'hello', u'hi'))
+
+print "hello world".endswith(u'hello')
+print "hello world".endswith(u'world')
+print "hello world".startswith(u'hello')
+print "hello world".startswith(u'world')
+
+print float(u'1.0')