Stackless issue python#188: fixes, tests and changelog enty

Fix a error handling in the YIELD_FROM finalisation code.
Add tests and changelog.txt

Author: akruis

Python/ceval.c

@@ -1110,10 +1110,13 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
                     && PyErr_ExceptionMatches(PyExc_StopIteration))
                     call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, f);
                 err = _PyGen_FetchStopIterationValue(&retval);
-                if (err < 0)
-                    goto error;
-                Py_DECREF(receiver);
-                SET_TOP(retval);
+                if (err < 0) {
+                    retval = NULL;
+                }
+                else {
+                    Py_DECREF(receiver);
+                    SET_TOP(retval);
+                }
             }
             else {
                 /* receiver remains on stack, retval is value to be yielded */

Stackless/changelog.txt

@@ -9,6 +9,17 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://github.com/stackless-dev/stackless/issues/188
+  Enable stackless calls of sub-iterators and coroutines (technically: the
+  YIELD_FROM opcode) and of the following methods, if soft-switching is
+  enabled:
+    - generator.send() (generator.__next__() was already stackless);
+    - coroutine.send();
+    - coroutine_wrapper.__next__() and coroutine_wrapper.send();
+    - async_generator_asend.__next__() and async_generator_asend.send().
+  With this change it is possible to soft switch into/from the compound
+  statements "async for" and "async with".
+
 - https://github.com/stackless-dev/stackless/issues/190
   Silently ignore attempts to close a running generator, coroutine or
   asynchronous generator. This avoids spurious error messages, if such an

Stackless/unittests/test_generator.py

@@ -66,10 +66,10 @@ def gen():
                 raise
 
         def task(generator):
-            l = [i for i in generator]
-            self.assertListEqual(l, [1])
+            li = [i for i in generator]
+            self.assertListEqual(li, [1])
 
-        self.run_GC_test(task,gen())
+        self.run_GC_test(task, gen())
 
     def testGCRunningCoroutine(self):
         async def coro():
@@ -242,5 +242,125 @@ def test_finalizer(self):
                     self._test_finalizer(pf_dump, pf_load)
 
 
+class TestStacklessOperations(StacklessTestCase):
+    def assertLevel(self, expected=0):
+        self.assertTrue(stackless.current.alive)
+        if stackless.enable_softswitch(None):
+            self.assertEqual(stackless.current.nesting_level, expected)
+        else:
+            self.assertGreater(stackless.current.nesting_level, expected)
+
+    def gen_1_2(self):
+        self.assertLevel()
+        yield 1
+        self.assertLevel()
+        yield 2
+        self.assertLevel()
+
+    def supergen(self, gen):
+        self.assertLevel()
+        yield from gen
+        self.assertLevel()
+
+    @types.coroutine
+    def wrapped_generator_coro(self):
+        self.assertLevel()
+        yield
+        self.assertLevel()
+        yield
+        self.assertLevel()
+
+    @types.coroutine
+    def coro1yield(self):
+        yield
+
+    async def coro(self):
+        self.assertLevel()
+        await self.coro1yield()
+        self.assertLevel()
+        await self.coro1yield()
+        self.assertLevel()
+
+    async def agen_1_2(self):
+        self.assertLevel()
+        await self.coro1yield()
+        yield 1
+        await self.coro1yield()
+        self.assertLevel()
+        yield 2
+        await self.coro1yield()
+        self.assertLevel()
+
+    @contextlib.asynccontextmanager
+    async def async_ctx_mgr(self):
+        self.assertLevel()
+        await self.coro1yield()
+        try:
+            yield
+        finally:
+            self.assertLevel()
+            await self.coro1yield()
+
+    def run_until_complete(self, coro):
+        n = 0
+        it = coro.__await__()
+        while True:
+            try:
+                x = it.send(None)
+                self.assertIsNone(x)
+                n += 1
+            except StopIteration:
+                return n
+
+    def test_yield_from(self):
+        li = [i for i in self.supergen(self.gen_1_2())]
+        self.assertListEqual(li, [1, 2])
+
+    def test_async_for(self):
+        async def test():
+            li = []
+            async for v in self.agen_1_2():
+                li.append(v)
+            self.assertListEqual(li, [1, 2])
+
+        t = test()
+        n = self.run_until_complete(t)
+        self.assertEqual(n, 3)
+
+    def test_async_with(self):
+        async def test():
+            async with self.async_ctx_mgr():
+                await self.coro()
+
+        t = test()
+        n = self.run_until_complete(t)
+        self.assertEqual(n, 4)
+
+    def test_coroutine_wrapper(self):
+        async def test():
+            await self.wrapped_generator_coro()
+
+        t = test()
+        n = self.run_until_complete(t)
+        self.assertEqual(n, 2)
+
+    def test_coroutine(self):
+        async def test():
+            await self.coro()
+
+        t = test()
+        n = self.run_until_complete(t)
+        self.assertEqual(n, 2)
+
+    def test_async_iter_asend_send(self):
+        async def test():
+            a = self.agen_1_2().__aiter__()
+            x = a.asend(None).send(None)
+
+        t = test()
+        n = self.run_until_complete(t)
+        self.assertEqual(n, 0)
+
+
 if __name__ == '__main__':
     unittest.main()