Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledCoroutineType.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     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.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /** Compiled Coroutines.
  *
  * Unlike in CPython, we have one type for just coroutines, this doesn't do generators
@@ -29,7 +14,7 @@
 #ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
 #include "nuitka/prelude.h"
-#include "structmember.h"
+#include <structmember.h>
 #endif
 
 // For reporting about reference counts per type.
@@ -72,8 +57,8 @@ static void Nuitka_MarkCoroutineAsNotRunning(struct Nuitka_CoroutineObject *coro
 }
 
 static PyObject *_Nuitka_Coroutine_send(PyThreadState *tstate, struct Nuitka_CoroutineObject *coroutine,
-                                        PyObject *value, bool closing, PyObject *exception_type,
-                                        PyObject *exception_value, PyTracebackObject *exception_tb);
+                                        PyObject *value, bool closing,
+                                        struct Nuitka_ExceptionPreservationItem *exception_state);
 
 static long Nuitka_Coroutine_tp_hash(struct Nuitka_CoroutineObject *coroutine) { return coroutine->m_counter; }
 
@@ -133,13 +118,13 @@ static int Nuitka_Coroutine_set_qualname(struct Nuitka_CoroutineObject *coroutin
 
 static PyObject *Nuitka_Coroutine_get_cr_await(struct Nuitka_CoroutineObject *coroutine) {
     CHECK_OBJECT(coroutine);
-    CHECK_OBJECT_X(coroutine->m_yieldfrom);
+    CHECK_OBJECT_X(coroutine->m_yield_from);
 
-    if (coroutine->m_yieldfrom) {
-        Py_INCREF(coroutine->m_yieldfrom);
-        return coroutine->m_yieldfrom;
+    if (coroutine->m_yield_from) {
+        Py_INCREF(coroutine->m_yield_from);
+        return coroutine->m_yield_from;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -169,7 +154,7 @@ static PyObject *Nuitka_Coroutine_get_frame(struct Nuitka_CoroutineObject *corou
         Py_INCREF(coroutine->m_frame);
         return (PyObject *)coroutine->m_frame;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -196,30 +181,29 @@ static void Nuitka_Coroutine_release_closure(struct Nuitka_CoroutineObject *coro
 }
 
 // Note: Shared with asyncgen.
-static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yieldfrom, PyObject *send_value,
+static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yield_from, PyObject *send_value,
                                        PyObject **returned_value, bool mode) {
     // Send iteration value to the sub-generator, which may be a CPython
     // generator object, something with an iterator next, or a send method,
     // where the later is only required if values other than "None" need to
     // be passed in.
-    CHECK_OBJECT(yieldfrom);
+    CHECK_OBJECT(yield_from);
     CHECK_OBJECT_X(send_value);
 
     assert(send_value != NULL || HAS_ERROR_OCCURRED(tstate));
 
     PyObject *retval;
 
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
+    struct Nuitka_ExceptionPreservationItem exception_state;
 
-    FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
+    FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
 
-    if (exception_type != NULL) {
+    if (HAS_EXCEPTION_STATE(&exception_state)) {
         // Exception, was thrown into us, need to send that to sub-generator.
         // We acquired ownership of the published exception and need to release it potentially.
 
         // Transfer exception owner this.
-        retval = _Nuitka_YieldFromPassExceptionTo(tstate, yieldfrom, exception_type, exception_value, exception_tb);
+        retval = _Nuitka_YieldFromPassExceptionTo(tstate, yield_from, &exception_state);
 
         // TODO: This wants to look at retval most definitely, send_value is going to be NULL.
         if (unlikely(send_value == NULL)) {
@@ -232,24 +216,28 @@ static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yieldfro
                 return NULL;
             }
         }
-    } else if (PyGen_CheckExact(yieldfrom) || PyCoro_CheckExact(yieldfrom)) {
-        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yieldfrom, Py_None);
-    } else if (send_value == Py_None && Nuitka_CoroutineWrapper_Check(yieldfrom)) {
+    } else if (PyGen_CheckExact(yield_from) || PyCoro_CheckExact(yield_from)) {
+        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yield_from, Py_None);
+    } else if (send_value == Py_None && Nuitka_CoroutineWrapper_Check(yield_from)) {
         struct Nuitka_CoroutineObject *yieldfrom_coroutine =
-            ((struct Nuitka_CoroutineWrapperObject *)yieldfrom)->m_coroutine;
+            ((struct Nuitka_CoroutineWrapperObject *)yield_from)->m_coroutine;
 
-        Py_INCREF(Py_None);
-        retval = _Nuitka_Coroutine_send(tstate, yieldfrom_coroutine, Py_None, mode ? false : true, NULL, NULL, NULL);
-    } else if (send_value == Py_None && Py_TYPE(yieldfrom)->tp_iternext != NULL) {
-        retval = Py_TYPE(yieldfrom)->tp_iternext(yieldfrom);
+        Py_INCREF_IMMORTAL(Py_None);
+
+        struct Nuitka_ExceptionPreservationItem no_exception_state;
+        INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+        retval = _Nuitka_Coroutine_send(tstate, yieldfrom_coroutine, Py_None, mode ? false : true, &no_exception_state);
+    } else if (send_value == Py_None && Py_TYPE(yield_from)->tp_iternext != NULL) {
+        retval = Py_TYPE(yield_from)->tp_iternext(yield_from);
     } else {
 #if 0
         // TODO: Add slow mode traces.
-        PRINT_ITEM(yieldfrom);
+        PRINT_ITEM(yield_from);
         PRINT_NEW_LINE();
 #endif
 
-        retval = PyObject_CallMethodObjArgs(yieldfrom, const_str_plain_send, send_value, NULL);
+        retval = PyObject_CallMethodObjArgs(yield_from, const_str_plain_send, send_value, NULL);
     }
 
     // Check the sub-generator result
@@ -257,7 +245,7 @@ static PyObject *_Nuitka_YieldFromCore(PyThreadState *tstate, PyObject *yieldfro
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
         if (error == NULL) {
-            Py_INCREF(Py_None);
+            Py_INCREF_IMMORTAL(Py_None);
             *returned_value = Py_None;
         } else if (likely(EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration))) {
             // The sub-generator has given an exception. In case of
@@ -284,23 +272,23 @@ static PyObject *_Nuitka_YieldFromCoroutineCore(PyThreadState *tstate, struct Nu
     CHECK_OBJECT(coroutine);
     CHECK_OBJECT_X(send_value);
 
-    PyObject *yieldfrom = coroutine->m_yieldfrom;
-    CHECK_OBJECT(yieldfrom);
+    PyObject *yield_from = coroutine->m_yield_from;
+    CHECK_OBJECT(yield_from);
 
     // Need to make it unaccessible while using it.
-    coroutine->m_yieldfrom = NULL;
+    coroutine->m_yield_from = NULL;
 
     PyObject *returned_value;
-    PyObject *yielded = _Nuitka_YieldFromCore(tstate, yieldfrom, send_value, &returned_value, mode);
+    PyObject *yielded = _Nuitka_YieldFromCore(tstate, yield_from, send_value, &returned_value, mode);
 
     if (yielded == NULL) {
-        assert(coroutine->m_yieldfrom == NULL);
-        Py_DECREF(yieldfrom);
+        assert(coroutine->m_yield_from == NULL);
+        Py_DECREF(yield_from);
 
         yielded = ((coroutine_code)coroutine->m_code)(tstate, coroutine, returned_value);
     } else {
-        assert(coroutine->m_yieldfrom == NULL);
-        coroutine->m_yieldfrom = yieldfrom;
+        assert(coroutine->m_yield_from == NULL);
+        coroutine->m_yield_from = yield_from;
     }
 
     return yielded;
@@ -384,30 +372,26 @@ static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value)
 //   be normalized.
 
 static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka_CoroutineObject *coroutine,
-                                            PyObject *value, bool closing, PyObject *exception_type,
-                                            PyObject *exception_value, PyTracebackObject *exception_tb,
+                                            PyObject *value, bool closing,
+                                            struct Nuitka_ExceptionPreservationItem *exception_state,
                                             PyObject **result) {
     CHECK_OBJECT(coroutine);
     assert(Nuitka_Coroutine_Check((PyObject *)coroutine));
-    CHECK_OBJECT_X(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE_X(exception_state);
     CHECK_OBJECT_X(value);
 
 #if _DEBUG_COROUTINE
     PRINT_COROUTINE_STATUS("Enter", coroutine);
     PRINT_COROUTINE_STRING("closing", closing ? "(closing) " : "(not closing) ");
     PRINT_COROUTINE_VALUE("value", value);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
 #endif
 
     // Not both a value and an exception please.
     if (value != NULL) {
-        assert(exception_type == NULL);
-        assert(exception_value == NULL);
-        assert(exception_tb == NULL);
+        ASSERT_EMPTY_EXCEPTION_STATE(exception_state);
     }
 
     if (coroutine->m_status == status_Unused && value != NULL && value != Py_None) {
@@ -449,11 +433,11 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
         Nuitka_MarkCoroutineAsRunning(coroutine);
 
         // Check for thrown exception, publish it to the coroutine code.
-        if (unlikely(exception_type)) {
+        if (unlikely(HAS_EXCEPTION_STATE(exception_state))) {
             assert(value == NULL);
 
             // Transfer exception ownership to published.
-            RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+            RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
         }
 
 #if _DEBUG_COROUTINE
@@ -466,7 +450,7 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
 
         PyObject *yielded;
 
-        if (coroutine->m_yieldfrom == NULL) {
+        if (coroutine->m_yield_from == NULL) {
             yielded = ((coroutine_code)coroutine->m_code)(tstate, coroutine, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -474,16 +458,14 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
             Py_XDECREF(value);
         }
 
-        // If the coroutine returns with m_yieldfrom set, it wants us to yield
+        // If the coroutine returns with m_yield_from set, it wants us to yield
         // from that value from now on.
-        while (yielded == NULL && coroutine->m_yieldfrom != NULL) {
+        while (yielded == NULL && coroutine->m_yield_from != NULL) {
             yielded = Nuitka_YieldFromCoroutineNext(tstate, coroutine);
         }
 
         Nuitka_MarkCoroutineAsNotRunning(coroutine);
 
-        tstate = PyThreadState_GET();
-
         // Remove the back frame from coroutine if it's there.
         if (coroutine->m_frame) {
             // assert(tstate->frame == &coroutine->m_frame->m_frame);
@@ -550,30 +532,7 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
 
                     return PYGEN_RETURN;
                 } else if (error == PyExc_StopIteration) {
-                    PyObject *saved_exception_type, *saved_exception_value;
-                    PyTracebackObject *saved_exception_tb;
-
-                    // TODO: For Python3.12, this kind of code ought to use tstate methods entirely.
-                    FETCH_ERROR_OCCURRED(tstate, &saved_exception_type, &saved_exception_value, &saved_exception_tb);
-                    NORMALIZE_EXCEPTION(tstate, &saved_exception_type, &saved_exception_value, &saved_exception_tb);
-
-                    PyErr_Format(PyExc_RuntimeError, "coroutine raised StopIteration");
-
-                    FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
-
-                    RAISE_EXCEPTION_WITH_CAUSE(tstate, &exception_type, &exception_value, &exception_tb,
-                                               saved_exception_value);
-
-                    CHECK_OBJECT(exception_value);
-                    CHECK_OBJECT(saved_exception_value);
-
-                    Py_INCREF(saved_exception_value);
-                    PyException_SetContext(exception_value, saved_exception_value);
-
-                    Py_DECREF(saved_exception_type);
-                    Py_XDECREF(saved_exception_tb);
-
-                    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+                    RAISE_RUNTIME_ERROR_RAISED_STOP_ITERATION(tstate, "coroutine raised StopIteration");
 
 #if _DEBUG_COROUTINE
                     PRINT_COROUTINE_STATUS("Leave with exception set", coroutine);
@@ -592,9 +551,7 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
         Py_XDECREF(value);
 
         // Release exception if any, we are finished with it and will raise another.
-        Py_XDECREF(exception_type);
-        Py_XDECREF(exception_value);
-        Py_XDECREF(exception_tb);
+        RELEASE_ERROR_OCCURRED_STATE_X(exception_state);
 
         /* This is for status_Finished */
         assert(coroutine->m_status == status_Finished);
@@ -626,18 +583,15 @@ static PySendResult _Nuitka_Coroutine_sendR(PyThreadState *tstate, struct Nuitka
 }
 
 static PyObject *_Nuitka_Coroutine_send(PyThreadState *tstate, struct Nuitka_CoroutineObject *coroutine,
-                                        PyObject *value, bool closing, PyObject *exception_type,
-                                        PyObject *exception_value, PyTracebackObject *exception_tb) {
+                                        PyObject *value, bool closing,
+                                        struct Nuitka_ExceptionPreservationItem *exception_state) {
 
     PyObject *result;
-    PySendResult res = _Nuitka_Coroutine_sendR(tstate, coroutine, value, closing, exception_type, exception_value,
-                                               exception_tb, &result);
+    PySendResult res = _Nuitka_Coroutine_sendR(tstate, coroutine, value, closing, exception_state, &result);
 
     switch (res) {
     case PYGEN_RETURN:
-        if (result == NULL) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
-        } else {
+        if (result != NULL) {
             if (result != Py_None) {
                 Nuitka_SetStopIterationValue(tstate, result);
             }
@@ -663,7 +617,11 @@ static PyObject *Nuitka_Coroutine_send(struct Nuitka_CoroutineObject *coroutine,
     Py_INCREF(value);
 
     PyThreadState *tstate = PyThreadState_GET();
-    PyObject *result = _Nuitka_Coroutine_send(tstate, coroutine, value, false, NULL, NULL, NULL);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PyObject *result = _Nuitka_Coroutine_send(tstate, coroutine, value, false, &exception_state);
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
@@ -682,9 +640,10 @@ static bool _Nuitka_Coroutine_close(PyThreadState *tstate, struct Nuitka_Corouti
     CHECK_OBJECT(coroutine);
 
     if (coroutine->m_status == status_Running) {
-        Py_INCREF(PyExc_GeneratorExit);
+        struct Nuitka_ExceptionPreservationItem exception_state;
+        SET_EXCEPTION_PRESERVATION_STATE_FROM_ARGS(tstate, &exception_state, PyExc_GeneratorExit, NULL, NULL);
 
-        PyObject *result = _Nuitka_Coroutine_send(tstate, coroutine, NULL, true, PyExc_GeneratorExit, NULL, NULL);
+        PyObject *result = _Nuitka_Coroutine_send(tstate, coroutine, NULL, true, &exception_state);
 
         if (unlikely(result)) {
             Py_DECREF(result);
@@ -707,7 +666,7 @@ static PyObject *Nuitka_Coroutine_close(struct Nuitka_CoroutineObject *coroutine
     if (unlikely(r == false)) {
         return NULL;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -716,12 +675,11 @@ static PyObject *Nuitka_Coroutine_close(struct Nuitka_CoroutineObject *coroutine
 static bool Nuitka_AsyncgenAsend_Check(PyObject *object);
 struct Nuitka_AsyncgenAsendObject;
 static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuitka_AsyncgenAsendObject *asyncgen_asend,
-                                              PyObject *exception_type, PyObject *exception_value,
-                                              PyTracebackObject *exception_tb);
+                                              struct Nuitka_ExceptionPreservationItem *exception_state);
 #endif
 
-static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                           PyTracebackObject **exception_tb);
+static bool _Nuitka_Generator_check_throw(PyThreadState *tstate,
+                                          struct Nuitka_ExceptionPreservationItem *exception_state);
 
 // This function is called when yielding to a coroutine through "_Nuitka_YieldFromPassExceptionTo"
 // and potentially wrapper objects used by generators, or by the throw method itself.
@@ -730,98 +688,90 @@ static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exc
 //   value of exception_type will not be NULL, but the actual exception will not necessarily
 //   be normalized.
 static PyObject *_Nuitka_Coroutine_throw2(PyThreadState *tstate, struct Nuitka_CoroutineObject *coroutine, bool closing,
-                                          PyObject *exception_type, PyObject *exception_value,
-                                          PyTracebackObject *exception_tb) {
+                                          struct Nuitka_ExceptionPreservationItem *exception_state) {
     CHECK_OBJECT(coroutine);
     assert(Nuitka_Coroutine_Check((PyObject *)coroutine));
-    CHECK_OBJECT(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE(exception_state);
 
 #if _DEBUG_COROUTINE
     PRINT_COROUTINE_STATUS("Enter", coroutine);
     PRINT_COROUTINE_STRING("closing", closing ? "(closing) " : "(not closing) ");
-    PRINT_COROUTINE_VALUE("yieldfrom", coroutine->m_yieldfrom);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_COROUTINE_VALUE("yield_from", coroutine->m_yield_from);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
-    if (coroutine->m_yieldfrom != NULL) {
-        if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+    if (coroutine->m_yield_from != NULL) {
+        if (EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
             // Coroutines need to close the yield_from.
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            bool res = Nuitka_gen_close_iter(tstate, coroutine->m_yieldfrom);
+            bool res = Nuitka_gen_close_iter(tstate, coroutine->m_yield_from);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 
             if (res == false) {
                 // Release exception, we are done with it now and pick up the new one.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
-                FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
+                FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
             }
 
             // Transferred exception ownership to "_Nuitka_Coroutine_send".
-            return _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, exception_type, exception_value,
-                                          exception_tb);
+            return _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, exception_state);
         }
 
         PyObject *ret;
 
 #if _DEBUG_COROUTINE
         PRINT_COROUTINE_STATUS("Passing to yielded from", coroutine);
-        PRINT_COROUTINE_VALUE("m_yieldfrom", coroutine->m_yieldfrom);
+        PRINT_COROUTINE_VALUE("m_yield_from", coroutine->m_yield_from);
         PRINT_NEW_LINE();
 #endif
 
-        if (Nuitka_Generator_Check(coroutine->m_yieldfrom)) {
-            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)coroutine->m_yieldfrom);
+        if (Nuitka_Generator_Check(coroutine->m_yield_from)) {
+            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)coroutine->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Generator_throw2".
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Generator_throw2(tstate, gen, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
-        } else if (Nuitka_Coroutine_Check(coroutine->m_yieldfrom)) {
-            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)coroutine->m_yieldfrom);
+        } else if (Nuitka_Coroutine_Check(coroutine->m_yield_from)) {
+            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)coroutine->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        } else if (PyGen_CheckExact(coroutine->m_yieldfrom) || PyCoro_CheckExact(coroutine->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)coroutine->m_yieldfrom;
+        } else if (PyGen_CheckExact(coroutine->m_yield_from) || PyCoro_CheckExact(coroutine->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)coroutine->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_type, exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 #endif
-        } else if (Nuitka_CoroutineWrapper_Check(coroutine->m_yieldfrom)) {
+        } else if (Nuitka_CoroutineWrapper_Check(coroutine->m_yield_from)) {
             struct Nuitka_CoroutineObject *coro =
-                ((struct Nuitka_CoroutineWrapperObject *)coroutine->m_yieldfrom)->m_coroutine;
+                ((struct Nuitka_CoroutineWrapperObject *)coroutine->m_yield_from)->m_coroutine;
 
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 #if PYTHON_VERSION >= 0x360
-        } else if (Nuitka_AsyncgenAsend_Check(coroutine->m_yieldfrom)) {
+        } else if (Nuitka_AsyncgenAsend_Check(coroutine->m_yield_from)) {
             struct Nuitka_AsyncgenAsendObject *asyncgen_asend =
-                ((struct Nuitka_AsyncgenAsendObject *)coroutine->m_yieldfrom);
+                ((struct Nuitka_AsyncgenAsendObject *)coroutine->m_yield_from);
 
             // Transferred exception ownership to "_Nuitka_AsyncgenAsend_throw2".
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 #endif
         } else {
-            PyObject *meth = PyObject_GetAttr(coroutine->m_yieldfrom, const_str_plain_throw);
+            PyObject *meth = PyObject_GetAttr(coroutine->m_yield_from, const_str_plain_throw);
             if (unlikely(meth == NULL)) {
                 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
                     // Release exception, we are done with it now.
-                    Py_DECREF(exception_type);
-                    Py_XDECREF(exception_value);
-                    Py_XDECREF(exception_tb);
+                    RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                     return NULL;
                 }
@@ -832,35 +782,33 @@ static PyObject *_Nuitka_Coroutine_throw2(PyThreadState *tstate, struct Nuitka_C
                 goto throw_here;
             }
 
-            CHECK_OBJECT(exception_type);
+            CHECK_EXCEPTION_STATE(exception_state);
 
 #if 0
             // TODO: Add slow mode traces.
-            PRINT_ITEM(coroutine->m_yieldfrom);
+            PRINT_ITEM(coroutine->m_yield_from);
             PRINT_NEW_LINE();
 #endif
             Nuitka_MarkCoroutineAsRunning(coroutine);
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
             Nuitka_MarkCoroutineAsNotRunning(coroutine);
 
             Py_DECREF(meth);
 
             // Release exception, we are done with it now.
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
         }
 
         if (unlikely(ret == NULL)) {
             // Return value or exception, not to continue with yielding from.
-            if (coroutine->m_yieldfrom != NULL) {
-                CHECK_OBJECT(coroutine->m_yieldfrom);
+            if (coroutine->m_yield_from != NULL) {
+                CHECK_OBJECT(coroutine->m_yield_from);
 #if _DEBUG_COROUTINE
                 PRINT_COROUTINE_STATUS("Null return, yield from removal:", coroutine);
-                PRINT_COROUTINE_VALUE("yieldfrom", coroutine->m_yieldfrom);
+                PRINT_COROUTINE_VALUE("yield_from", coroutine->m_yield_from);
 #endif
-                Py_DECREF(coroutine->m_yieldfrom);
-                coroutine->m_yieldfrom = NULL;
+                Py_DECREF(coroutine->m_yield_from);
+                coroutine->m_yield_from = NULL;
             }
 
             PyObject *val;
@@ -873,15 +821,22 @@ static PyObject *_Nuitka_Coroutine_throw2(PyThreadState *tstate, struct Nuitka_C
                 PRINT_NEW_LINE();
 #endif
 
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
                 // The ownership of val is transferred.
-                ret = _Nuitka_Coroutine_send(tstate, coroutine, val, false, NULL, NULL, NULL);
+                ret = _Nuitka_Coroutine_send(tstate, coroutine, val, false, &no_exception_state);
             } else {
 #if _DEBUG_COROUTINE
                 PRINT_COROUTINE_STATUS("Sending exception value into ourselves", coroutine);
                 PRINT_CURRENT_EXCEPTION();
                 PRINT_NEW_LINE();
 #endif
-                ret = _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, NULL, NULL, NULL);
+
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+                ret = _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, &no_exception_state);
             }
 
 #if _DEBUG_COROUTINE
@@ -907,15 +862,14 @@ static PyObject *_Nuitka_Coroutine_throw2(PyThreadState *tstate, struct Nuitka_C
 throw_here:
     // We continue to have exception ownership here.
 
-    if (unlikely(_Nuitka_Generator_check_throw2(tstate, &exception_type, &exception_value, &exception_tb) == false)) {
-        // Exception was released by _Nuitka_Generator_check_throw2 already.
+    if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
+        // Exception was released by _Nuitka_Generator_check_throw already.
         return NULL;
     }
 
     if (coroutine->m_status == status_Running) {
         // Transferred exception ownership to "_Nuitka_Coroutine_send".
-        PyObject *result =
-            _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, exception_type, exception_value, exception_tb);
+        PyObject *result = _Nuitka_Coroutine_send(tstate, coroutine, NULL, false, exception_state);
         return result;
     } else if (coroutine->m_status == status_Finished) {
 
@@ -937,30 +891,31 @@ throw_here:
 #endif
             );
 
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
             return NULL;
         }
 #endif
         // Passing exception to publication.
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
         return NULL;
     } else {
+        PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(exception_state);
+
         if (exception_tb == NULL) {
             // TODO: Our compiled objects really need a way to store common
             // stuff in a "shared" part across all instances, and outside of
             // run time, so we could reuse this.
             struct Nuitka_FrameObject *frame =
                 MAKE_FUNCTION_FRAME(tstate, coroutine->m_code_object, coroutine->m_module, 0);
-            exception_tb = MAKE_TRACEBACK(frame, coroutine->m_code_object->co_firstlineno);
+            SET_EXCEPTION_STATE_TRACEBACK(exception_state,
+                                          MAKE_TRACEBACK(frame, coroutine->m_code_object->co_firstlineno));
             Py_DECREF(frame);
         }
 
         // Passing exception to publication.
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
 #if _DEBUG_COROUTINE
         PRINT_COROUTINE_STATUS("Finishing from exception", coroutine);
@@ -994,14 +949,16 @@ static PyObject *Nuitka_Coroutine_throw(struct Nuitka_CoroutineObject *coroutine
     PRINT_NEW_LINE();
 #endif
 
+    PyThreadState *tstate = PyThreadState_GET();
+
     // Handing ownership of exception over, we need not release it ourselves
-    Py_INCREF(exception_type);
-    Py_XINCREF(exception_value);
-    Py_XINCREF(exception_tb);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    if (_Nuitka_Generator_make_throw_exception_state(tstate, &exception_state, exception_type, exception_value,
+                                                     exception_tb) == false) {
+        return NULL;
+    }
 
-    PyThreadState *tstate = PyThreadState_GET();
-    PyObject *result =
-        _Nuitka_Coroutine_throw2(tstate, coroutine, false, exception_type, exception_value, exception_tb);
+    PyObject *result = _Nuitka_Coroutine_throw2(tstate, coroutine, false, &exception_state);
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
@@ -1031,7 +988,7 @@ static long Nuitka_Coroutine_tp_traverse(struct Nuitka_CoroutineObject *coroutin
     CHECK_OBJECT(coroutine);
 
     // TODO: Identify the impact of not visiting owned objects like module
-    Py_VISIT(coroutine->m_yieldfrom);
+    Py_VISIT(coroutine->m_yield_from);
 
     for (Py_ssize_t i = 0; i < coroutine->m_closure_given; i++) {
         Py_VISIT(coroutine->m_closure[i]);
@@ -1085,7 +1042,11 @@ static PySendResult _Nuitka_Coroutine_am_send(struct Nuitka_CoroutineObject *cor
 
     // We need to transfer ownership of the sent value.
     Py_INCREF(arg);
-    PySendResult res = _Nuitka_Coroutine_sendR(tstate, coroutine, arg, false, NULL, NULL, NULL, result);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PySendResult res = _Nuitka_Coroutine_sendR(tstate, coroutine, arg, false, &exception_state, result);
 
 #if _DEBUG_COROUTINE
     PRINT_COROUTINE_STATUS("Leave", coroutine);
@@ -1103,9 +1064,8 @@ static void Nuitka_Coroutine_tp_finalize(struct Nuitka_CoroutineObject *coroutin
 
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     bool close_result = _Nuitka_Coroutine_close(tstate, coroutine);
 
@@ -1114,7 +1074,7 @@ static void Nuitka_Coroutine_tp_finalize(struct Nuitka_CoroutineObject *coroutin
     }
 
     /* Restore the saved exception if any. */
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
 #define MAX_COROUTINE_FREE_LIST_COUNT 100
@@ -1134,9 +1094,8 @@ static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine
     PyThreadState *tstate = PyThreadState_GET();
 
     // Save the current exception, if any, we must preserve it.
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
 #if _DEBUG_COROUTINE
     PRINT_COROUTINE_STATUS("Enter", coroutine);
@@ -1154,7 +1113,7 @@ static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine
     // Allow for above code to resurrect the coroutine.
     Py_SET_REFCNT(coroutine, Py_REFCNT(coroutine) - 1);
     if (Py_REFCNT(coroutine) >= 1) {
-        RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
         return;
     }
 
@@ -1182,7 +1141,7 @@ static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine
     /* Put the object into free list or release to GC */
     releaseToFreeList(free_list_coros, coroutine, MAX_COROUTINE_FREE_LIST_COUNT);
 
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
 // TODO: Set "__doc__" automatically for method clones of compiled types from
@@ -1194,7 +1153,7 @@ static PyMethodDef Nuitka_Coroutine_methods[] = {{"send", (PyCFunction)Nuitka_Co
 
 // TODO: Set "__doc__" automatically for method clones of compiled types from
 // the documentation of built-in original type.
-static PyGetSetDef Nuitka_Coroutine_getsetlist[] = {
+static PyGetSetDef Nuitka_Coroutine_tp_getset[] = {
     {(char *)"__name__", (getter)Nuitka_Coroutine_get_name, (setter)Nuitka_Coroutine_set_name, NULL},
     {(char *)"__qualname__", (getter)Nuitka_Coroutine_get_qualname, (setter)Nuitka_Coroutine_set_qualname, NULL},
     {(char *)"cr_await", (getter)Nuitka_Coroutine_get_cr_await, (setter)NULL, NULL},
@@ -1251,7 +1210,7 @@ PyTypeObject Nuitka_Coroutine_Type = {
     0,                                                                  // tp_iternext
     Nuitka_Coroutine_methods,                                           // tp_methods
     Nuitka_Coroutine_members,                                           // tp_members
-    Nuitka_Coroutine_getsetlist,                                        // tp_getset
+    Nuitka_Coroutine_tp_getset,                                         // tp_getset
     0,                                                                  // tp_base
     0,                                                                  // tp_dict
     0,                                                                  // tp_descr_get
@@ -1390,12 +1349,15 @@ static int Nuitka_PyInterpreterFrame_GetLine(_PyInterpreterFrame *frame) {
     // we have the line number stored.
 
     int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
+#if PYTHON_VERSION < 0x3d0
     return PyCode_Addr2Line(frame->f_code, addr);
+#else
+    return PyCode_Addr2Line((PyCodeObject *)frame->f_executable, addr);
+#endif
 }
 
-static PyObject *computeCoroutineOrigin(int origin_depth) {
-    PyThreadState *tstate = _PyThreadState_GET();
-    _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
+static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth) {
+    _PyInterpreterFrame *current_frame = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
 
     // Create result tuple with correct size.
     int frame_count = 0;
@@ -1404,11 +1366,11 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
         frame = frame->previous;
         frame_count += 1;
     }
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(tstate, frame_count);
 
     frame = current_frame;
     for (int i = 0; i < frame_count; i++) {
-        PyCodeObject *code = frame->f_code;
+        PyCodeObject *code = Nuitka_InterpreterFrame_GetCodeObject(frame);
 
         int line = Nuitka_PyInterpreterFrame_GetLine(frame);
 
@@ -1423,7 +1385,7 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
 }
 
 #elif PYTHON_VERSION >= 0x370
-static PyObject *computeCoroutineOrigin(int origin_depth) {
+static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth) {
     PyFrameObject *frame = PyEval_GetFrame();
 
     int frame_count = 0;
@@ -1433,13 +1395,13 @@ static PyObject *computeCoroutineOrigin(int origin_depth) {
         frame_count += 1;
     }
 
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY(frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY(tstate, frame_count);
 
     frame = PyEval_GetFrame();
 
     for (int i = 0; i < frame_count; i++) {
-        PyObject *frame_info =
-            Py_BuildValue("OiO", frame->f_code->co_filename, PyFrame_GetLineNumber(frame), frame->f_code->co_name);
+        PyObject *frame_info = Py_BuildValue("OiO", Nuitka_Frame_GetCodeObject(frame)->co_filename,
+                                             PyFrame_GetLineNumber(frame), frame->f_code->co_name);
 
         assert(frame_info);
 
@@ -1489,7 +1451,7 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     result->m_qualname = qualname;
     Py_INCREF(qualname);
 
-    result->m_yieldfrom = NULL;
+    result->m_yield_from = NULL;
 
     memcpy(&result->m_closure[0], closure, closure_given * sizeof(struct Nuitka_CellObject *));
     result->m_closure_given = closure_given;
@@ -1515,7 +1477,7 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     if (origin_depth == 0) {
         result->m_origin = NULL;
     } else {
-        result->m_origin = computeCoroutineOrigin(origin_depth);
+        result->m_origin = computeCoroutineOrigin(tstate, origin_depth);
     }
 #endif
 
@@ -1530,9 +1492,21 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     return (PyObject *)result;
 }
 
+static inline PyCodeObject *_Nuitka_PyGen_GetCode(PyGenObject *gen) {
+#if PYTHON_VERSION < 0x3c0
+    return (PyCodeObject *)gen->gi_code;
+#elif PYTHON_VERSION < 0x3d0
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
+    return frame->f_code;
+#else
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
+    return (PyCodeObject *)frame->f_executable;
+#endif
+}
+
 static int gen_is_coroutine(PyObject *object) {
     if (PyGen_CheckExact(object)) {
-        PyCodeObject *code = (PyCodeObject *)((PyGenObject *)object)->gi_code;
+        PyCodeObject *code = _Nuitka_PyGen_GetCode((PyGenObject *)object);
 
         if (code->co_flags & CO_ITERABLE_COROUTINE) {
             return 1;
@@ -1679,14 +1653,18 @@ static PyObject *Nuitka_AIterWrapper_iternext(struct Nuitka_AIterWrapper *aw) {
     SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_StopIteration, aw->aw_aiter);
 #else
     if (!PyTuple_Check(aw->aw_aiter) && !PyExceptionInstance_Check(aw->aw_aiter)) {
-        SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_StopIteration, aw->aw_aiter);
+        Py_INCREF(PyExc_StopIteration);
+        Py_INCREF(aw->aw_aiter);
+
+        RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, aw->aw_aiter, NULL);
     } else {
-        PyObject *result = PyObject_CallFunctionObjArgs(PyExc_StopIteration, aw->aw_aiter, NULL);
+        PyObject *result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_StopIteration, aw->aw_aiter);
         if (unlikely(result == NULL)) {
             return NULL;
         }
 
-        SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, result);
+        Py_INCREF(PyExc_StopIteration);
+        RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, result, NULL);
     }
 #endif
 
@@ -1953,3 +1931,18 @@ static void _initCompiledCoroutineTypes(void) {
 #if PYTHON_VERSION >= 0x360
 #include "CompiledAsyncgenType.c"
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     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.