Issue python#112: Prepare Stackless 3.5

-  Preserve the new generator attributes __qualname__ and __name__ on pickling

https://bitbucket.org/stackless-dev/stackless/issues/112

Author: Anselm Kruis

Stackless/changelog.txt

@@ -9,6 +9,10 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://bitbucket.org/stackless-dev/stackless/issues/112
+  Adapt Stackless to Python 3.5.
+  - PyGenObject got two additional fields
+
 - https://bitbucket.org/stackless-dev/stackless/issues/111
   Restore the Python ABI function PyGen_New(). Previously Stackless named this
   function PyGenerator_New() and used a macro the redefine PyGen_New as

Stackless/pickling/prickelpit.c

@@ -2240,10 +2240,12 @@ static PyObject *
 gen_reduce(PyGenObject *gen)
 {
     PyObject *tup;
-    tup = Py_BuildValue("(O()(Oi))",
+    tup = Py_BuildValue("(O()(OiOO))",
                         &wrap_PyGen_Type,
                         gen->gi_frame,
-                        gen->gi_running
+                        gen->gi_running,
+                        gen->gi_name,
+                        gen->gi_qualname
                         );
     return tup;
 }
@@ -2270,12 +2272,22 @@ gen_setstate(PyObject *self, PyObject *args)
     PyGenObject *gen = (PyGenObject *) self;
     PyFrameObject *f;
     int gi_running;
+    PyObject *name = NULL;
+    PyObject *qualname = NULL;
 
     if (is_wrong_type(self->ob_type)) return NULL;
-    if (!PyArg_ParseTuple(args, "O!i:generator",
-                          &PyFrame_Type, &f, &gi_running))
+    if (!PyArg_ParseTuple(args, "O!i|OO:generator",
+                          &PyFrame_Type, &f, &gi_running, &name, &qualname))
         return NULL;
 
+    if (name == NULL) {
+        name = f->f_code->co_name;
+        assert(name != NULL);
+    }
+    if (qualname == NULL) {
+        qualname = name;
+    }
+
     if (!gi_running) {
         if ((f = slp_ensure_new_frame(f)) != NULL) {
             /* use a second one for late initialization */
@@ -2290,6 +2302,10 @@ gen_setstate(PyObject *self, PyObject *args)
             Py_SETREF(gen->gi_frame, f);
             Py_INCREF(f->f_code);
             Py_SETREF(gen->gi_code, (PyObject *)f->f_code);
+            Py_INCREF(name);
+            Py_SETREF(gen->gi_name, name);
+            Py_INCREF(qualname);
+            Py_SETREF(gen->gi_qualname, qualname);
             /* The frame the temporary generator references
                will have GeneratorExit raised on it, when the
                temporary generator is torn down.  So clearing
@@ -2317,6 +2333,10 @@ gen_setstate(PyObject *self, PyObject *args)
     Py_INCREF(f->f_code);
     Py_SETREF(gen->gi_code, (PyObject *)f->f_code);
     gen->gi_running = gi_running;
+    Py_INCREF(name);
+    Py_SETREF(gen->gi_name, name);
+    Py_INCREF(qualname);
+    Py_SETREF(gen->gi_qualname, qualname);
     Py_TYPE(gen) = Py_TYPE(gen)->tp_base;
     Py_INCREF(gen);
     return (PyObject *)gen;

Stackless/unittests/test_generator.py

@@ -2,6 +2,8 @@
 import gc
 import stackless
 import types
+import pickle
+import copyreg
 
 from support import StacklessTestCase
 
@@ -49,5 +51,52 @@ def test_wrap_generator_frame_code(self):
         self.assertIsNot(g0.gi_frame, g1.gi_frame)
         self.assertEqual(g0.__name__, "exhausted_generator")
 
+
+class TestGeneratorPickling(StacklessTestCase):
+    def test_name(self):
+        def g():
+            yield 1
+        gen_orig = g()
+        p = pickle.dumps(gen_orig)
+        gen_new = pickle.loads(p)
+
+        self.assertEqual(gen_new.__name__, gen_orig.__name__)
+
+    def test_qualname(self):
+        def g():
+            yield 1
+        gen_orig = g()
+        p = pickle.dumps(gen_orig)
+        gen_new = pickle.loads(p)
+
+        self.assertEqual(gen_new.__qualname__, gen_orig.__qualname__)
+
+    def test_noname(self):
+        # Ensure unpickling compatibility with Python versions < 3.5
+        def g():
+            yield 11
+        gen_orig = g()
+
+        r = copyreg.dispatch_table[type(gen_orig)](gen_orig)
+
+        self.assertIsInstance(r, tuple)
+        self.assertEqual(len(r), 3)
+        self.assertEqual(len(r[2]), 4)
+
+        gen_new = r[0](*r[1])
+        self.assertEqual(gen_new.__qualname__, "exhausted_generator")
+        self.assertEqual(gen_new.__name__, "exhausted_generator")
+        self.assertIs(type(gen_new), stackless._wrap.generator)
+
+        gen_new.__setstate__(r[2][:-2])
+
+        self.assertEqual(gen_new.__qualname__, "g")
+        self.assertEqual(gen_new.__name__, "g")
+        self.assertIs(type(gen_new), type(gen_orig))
+
+        v = gen_new.__next__()
+        self.assertEqual(v, 11)
+
+
 if __name__ == '__main__':
     unittest.main()