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

nuitka/build/static_src/CompiledAsyncgenType.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 Asyncgen.
  *
  * Unlike in CPython, we have one type for just asyncgen, this doesn't do
@@ -135,11 +120,11 @@ static int Nuitka_Asyncgen_set_qualname(struct Nuitka_AsyncgenObject *asyncgen,
 static PyObject *Nuitka_Asyncgen_get_ag_await(struct Nuitka_AsyncgenObject *asyncgen) {
     CHECK_OBJECT(asyncgen);
 
-    if (asyncgen->m_yieldfrom) {
-        Py_INCREF(asyncgen->m_yieldfrom);
-        return asyncgen->m_yieldfrom;
+    if (asyncgen->m_yield_from) {
+        Py_INCREF(asyncgen->m_yield_from);
+        return asyncgen->m_yield_from;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -169,7 +154,7 @@ static PyObject *Nuitka_Asyncgen_get_frame(struct Nuitka_AsyncgenObject *asyncge
         Py_INCREF(asyncgen->m_frame);
         return (PyObject *)asyncgen->m_frame;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -200,23 +185,23 @@ static PyObject *Nuitka_YieldFromAsyncgenCore(PyThreadState *tstate, struct Nuit
     CHECK_OBJECT(asyncgen);
     CHECK_OBJECT_X(send_value);
 
-    PyObject *yieldfrom = asyncgen->m_yieldfrom;
-    CHECK_OBJECT(yieldfrom);
+    PyObject *yield_from = asyncgen->m_yield_from;
+    CHECK_OBJECT(yield_from);
 
     // Need to make it unaccessible while using it.
-    asyncgen->m_yieldfrom = NULL;
+    asyncgen->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(asyncgen->m_yieldfrom == NULL);
-        Py_DECREF(yieldfrom);
+        assert(asyncgen->m_yield_from == NULL);
+        Py_DECREF(yield_from);
 
         yielded = ((asyncgen_code)asyncgen->m_code)(tstate, asyncgen, returned_value);
     } else {
-        assert(asyncgen->m_yieldfrom == NULL);
-        asyncgen->m_yieldfrom = yieldfrom;
+        assert(asyncgen->m_yield_from == NULL);
+        asyncgen->m_yield_from = yield_from;
     }
 
     return yielded;
@@ -295,28 +280,24 @@ static PyObject *Nuitka_YieldFromAsyncgenInitial(PyThreadState *tstate, struct N
 static PyObject *Nuitka_AsyncgenValueWrapper_New(PyObject *value);
 
 static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen,
-                                           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(asyncgen);
     assert(Nuitka_Asyncgen_Check((PyObject *)asyncgen));
     CHECK_OBJECT_X(value);
-    CHECK_OBJECT_X(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE_X(exception_state);
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Enter", asyncgen);
     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
 
     if (value != NULL) {
-        assert(exception_type == NULL);
-        assert(exception_value == NULL);
-        assert(exception_tb == NULL);
+        ASSERT_EMPTY_EXCEPTION_STATE(exception_state);
     }
 
     if (asyncgen->m_status == status_Unused && value != NULL && value != Py_None) {
@@ -357,11 +338,11 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
         asyncgen->m_running = true;
 
         // Check for thrown exception, and publish it.
-        if (unlikely(exception_type != NULL)) {
+        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 (asyncgen->m_frame) {
@@ -378,7 +359,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
 
         PyObject *yielded;
 
-        if (asyncgen->m_yieldfrom == NULL) {
+        if (asyncgen->m_yield_from == NULL) {
             yielded = ((asyncgen_code)asyncgen->m_code)(tstate, asyncgen, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -386,16 +367,14 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
             Py_XDECREF(value);
         }
 
-        // If the asyncgen returns with m_yieldfrom set, it wants us to yield
+        // If the asyncgen returns with m_yield_from set, it wants us to yield
         // from that value from now on.
-        while (yielded == NULL && asyncgen->m_yieldfrom != NULL) {
+        while (yielded == NULL && asyncgen->m_yield_from != NULL) {
             yielded = Nuitka_YieldFromAsyncgenNext(tstate, asyncgen);
         }
 
         Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
 
-        tstate = PyThreadState_GET();
-
         // Remove the back frame from asyncgen if it's there.
         if (asyncgen->m_frame) {
             // assert(tstate->frame == &asyncgen->m_frame->m_frame);
@@ -441,42 +420,21 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
             PyObject *error_occurred = GET_ERROR_OCCURRED(tstate);
 
             if (error_occurred == PyExc_StopIteration || error_occurred == PyExc_StopAsyncIteration) {
-                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);
-
+                char const *message;
                 if (error_occurred == PyExc_StopIteration) {
-                    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "async generator raised StopIteration");
+                    message = "async generator raised StopIteration";
                 } else {
-                    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError,
-                                                    "async generator raised StopAsyncIteration");
+                    message = "async generator raised StopAsyncIteration";
                 }
 
-                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, message);
                 return PYGEN_ERROR;
             }
 
             return PYGEN_ERROR;
         } else {
             // For normal yield, wrap the result value before returning.
-            if (asyncgen->m_yieldfrom == NULL) {
+            if (asyncgen->m_yield_from == NULL) {
                 // Transferred ownership to constructor of Nuitka_AsyncgenValueWrapper
                 PyObject *wrapped = Nuitka_AsyncgenValueWrapper_New(yielded);
                 yielded = wrapped;
@@ -491,21 +449,17 @@ static PySendResult _Nuitka_Asyncgen_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);
 
         return PYGEN_RETURN;
     }
 }
 
 static PyObject *_Nuitka_Asyncgen_send(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen, PyObject *value,
-                                       bool closing, PyObject *exception_type, PyObject *exception_value,
-                                       PyTracebackObject *exception_tb) {
+                                       bool closing, struct Nuitka_ExceptionPreservationItem *exception_state) {
 
     PyObject *result;
-    PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, value, closing, exception_type, exception_value,
-                                              exception_tb, &result);
+    PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, value, closing, exception_state, &result);
 
     switch (res) {
     case PYGEN_RETURN:
@@ -528,9 +482,10 @@ static bool _Nuitka_Asyncgen_close(PyThreadState *tstate, struct Nuitka_Asyncgen
     CHECK_OBJECT(asyncgen);
 
     if (asyncgen->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_Asyncgen_send(tstate, asyncgen, NULL, true, PyExc_GeneratorExit, NULL, NULL);
+        PyObject *result = _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, true, &exception_state);
 
         if (unlikely(result)) {
             Py_DECREF(result);
@@ -545,8 +500,8 @@ static bool _Nuitka_Asyncgen_close(PyThreadState *tstate, struct Nuitka_Asyncgen
     return true;
 }
 
-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 asyncgen through "_Nuitka_YieldFromPassExceptionTo"
 // and potentially wrapper objects used by generators, or by the throw method itself.
@@ -555,41 +510,35 @@ 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_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen,
-                                         bool close_on_genexit, PyObject *exception_type, PyObject *exception_value,
-                                         PyTracebackObject *exception_tb) {
+                                         bool close_on_genexit,
+                                         struct Nuitka_ExceptionPreservationItem *exception_state) {
     CHECK_OBJECT(asyncgen);
     assert(Nuitka_Asyncgen_Check((PyObject *)asyncgen));
-    CHECK_OBJECT(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE(exception_state);
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Enter", asyncgen);
-    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
-    if (asyncgen->m_yieldfrom != NULL) {
+    if (asyncgen->m_yield_from != NULL) {
         // TODO: This check is not done for coroutines, correct?
         if (close_on_genexit) {
-            if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+            if (EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
                 // Asynchronous generators need to close the yield_from.
                 Nuitka_MarkAsyncgenAsRunning(asyncgen);
-                bool res = Nuitka_gen_close_iter(tstate, asyncgen->m_yieldfrom);
+                bool res = Nuitka_gen_close_iter(tstate, asyncgen->m_yield_from);
                 Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
 
                 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);
-
-                    FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
+                    RELEASE_ERROR_OCCURRED_STATE(exception_state);
+                    FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
                 }
 
-                return _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, exception_type, exception_value,
-                                             exception_tb);
+                return _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, exception_state);
             }
         }
 
@@ -597,56 +546,55 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
 
 #if _DEBUG_ASYNCGEN
         PRINT_ASYNCGEN_STATUS("Passing to yielded from", asyncgen);
-        PRINT_COROUTINE_VALUE("m_yieldfrom", asyncgen->m_yieldfrom);
+        PRINT_COROUTINE_VALUE("m_yield_from", asyncgen->m_yield_from);
         PRINT_NEW_LINE();
 #endif
 
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        if (PyGen_CheckExact(asyncgen->m_yieldfrom) || PyCoro_CheckExact(asyncgen->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)asyncgen->m_yieldfrom;
+        if (PyGen_CheckExact(asyncgen->m_yield_from) || PyCoro_CheckExact(asyncgen->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)asyncgen->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
-            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_type, exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
         } else
 #endif
-            if (Nuitka_Generator_Check(asyncgen->m_yieldfrom)) {
-            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)asyncgen->m_yieldfrom);
+            if (Nuitka_Generator_Check(asyncgen->m_yield_from)) {
+            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)asyncgen->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Generator_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
-            ret = _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Generator_throw2(tstate, gen, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_Coroutine_Check(asyncgen->m_yieldfrom)) {
-            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)asyncgen->m_yieldfrom);
+        } else if (Nuitka_Coroutine_Check(asyncgen->m_yield_from)) {
+            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)asyncgen->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_CoroutineWrapper_Check(asyncgen->m_yieldfrom)) {
+        } else if (Nuitka_CoroutineWrapper_Check(asyncgen->m_yield_from)) {
             struct Nuitka_CoroutineObject *coro =
-                ((struct Nuitka_CoroutineWrapperObject *)asyncgen->m_yieldfrom)->m_coroutine;
+                ((struct Nuitka_CoroutineWrapperObject *)asyncgen->m_yield_from)->m_coroutine;
 
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_AsyncgenAsend_Check(asyncgen->m_yieldfrom)) {
+        } else if (Nuitka_AsyncgenAsend_Check(asyncgen->m_yield_from)) {
             struct Nuitka_AsyncgenAsendObject *asyncgen_asend =
-                ((struct Nuitka_AsyncgenAsendObject *)asyncgen->m_yieldfrom);
+                ((struct Nuitka_AsyncgenAsendObject *)asyncgen->m_yield_from);
 
             // Transferred exception ownership to "_Nuitka_AsyncgenAsend_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
-            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
         } else {
-            PyObject *meth = PyObject_GetAttr(asyncgen->m_yieldfrom, const_str_plain_throw);
+            PyObject *meth = PyObject_GetAttr(asyncgen->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;
                 }
@@ -657,24 +605,22 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
                 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_MarkAsyncgenAsRunning(asyncgen);
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
 
             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)) {
@@ -683,17 +629,17 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
             if (_PyGen_FetchStopIterationValue(&val) == 0) {
                 CHECK_OBJECT(val);
 
-                asyncgen->m_yieldfrom = NULL;
+                asyncgen->m_yield_from = NULL;
 
                 // Return value, not to continue with yielding from.
-                if (asyncgen->m_yieldfrom != NULL) {
-                    CHECK_OBJECT(asyncgen->m_yieldfrom);
+                if (asyncgen->m_yield_from != NULL) {
+                    CHECK_OBJECT(asyncgen->m_yield_from);
 #if _DEBUG_ASYNCGEN
                     PRINT_ASYNCGEN_STATUS("Yield from removal:", asyncgen);
-                    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+                    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
 #endif
-                    Py_DECREF(asyncgen->m_yieldfrom);
-                    asyncgen->m_yieldfrom = NULL;
+                    Py_DECREF(asyncgen->m_yield_from);
+                    asyncgen->m_yield_from = NULL;
                 }
 
 #if _DEBUG_ASYNCGEN
@@ -702,15 +648,22 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
                 PRINT_NEW_LINE();
 #endif
 
-                ret = _Nuitka_Asyncgen_send(tstate, asyncgen, val, false, NULL, NULL, NULL);
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+                ret = _Nuitka_Asyncgen_send(tstate, asyncgen, val, false, &no_exception_state);
             } else {
 #if _DEBUG_ASYNCGEN
                 PRINT_ASYNCGEN_STATUS("Sending exception value into ourselves", asyncgen);
-                PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+                PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
                 PRINT_CURRENT_EXCEPTION();
                 PRINT_NEW_LINE();
 #endif
-                ret = _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, NULL, NULL, NULL);
+
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+                ret = _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, &no_exception_state);
             }
 
 #if _DEBUG_ASYNCGEN
@@ -737,30 +690,33 @@ throw_here:
     PRINT_ASYNCGEN_STATUS("Need to throw into itself", asyncgen);
 #endif
 
-    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;
     }
 
     PyObject *result;
 
     if (asyncgen->m_status == status_Running) {
-        result = _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, exception_type, exception_value, exception_tb);
+        result = _Nuitka_Asyncgen_send(tstate, asyncgen, NULL, false, exception_state);
     } else if (asyncgen->m_status == status_Finished) {
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
         result = 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, asyncgen->m_code_object, asyncgen->m_module, 0);
-            exception_tb = MAKE_TRACEBACK(frame, asyncgen->m_code_object->co_firstlineno);
+            SET_EXCEPTION_STATE_TRACEBACK(exception_state,
+                                          MAKE_TRACEBACK(frame, asyncgen->m_code_object->co_firstlineno));
             Py_DECREF(frame);
         }
 
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
 #if _DEBUG_ASYNCGEN
         PRINT_ASYNCGEN_STATUS("Finishing from exception", asyncgen);
@@ -774,7 +730,7 @@ throw_here:
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Leave", asyncgen);
-    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
 #endif
@@ -804,11 +760,13 @@ static PyObject *Nuitka_Asyncgen_throw(PyThreadState *tstate, struct Nuitka_Asyn
 #endif
 
     // 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;
+    }
 
-    PyObject *result = _Nuitka_Asyncgen_throw2(tstate, asyncgen, false, exception_type, exception_value, exception_tb);
+    PyObject *result = _Nuitka_Asyncgen_throw2(tstate, asyncgen, false, &exception_state);
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
@@ -822,9 +780,7 @@ static PyObject *Nuitka_Asyncgen_throw(PyThreadState *tstate, struct Nuitka_Asyn
     PRINT_CURRENT_EXCEPTION();
 #endif
 
-    CHECK_OBJECT(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE(&exception_state);
 
     return result;
 }
@@ -937,7 +893,10 @@ static PySendResult _Nuitka_Asyncgen_am_send(struct Nuitka_AsyncgenObject *async
 
     PyThreadState *tstate = PyThreadState_GET();
 
-    PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, arg, false, NULL, NULL, NULL, result);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, arg, false, &exception_state, result);
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Leave", asyncgen);
@@ -955,9 +914,8 @@ static void Nuitka_Asyncgen_tp_finalize(struct Nuitka_AsyncgenObject *asyncgen)
 
     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_Asyncgen_close(tstate, asyncgen);
 
@@ -966,7 +924,7 @@ static void Nuitka_Asyncgen_tp_finalize(struct Nuitka_AsyncgenObject *asyncgen)
     }
 
     /* 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_ASYNCGEN_FREE_LIST_COUNT 100
@@ -987,13 +945,12 @@ static void Nuitka_Asyncgen_tp_dealloc(struct Nuitka_AsyncgenObject *asyncgen) {
     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;
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
     PyObject *finalizer = asyncgen->m_finalizer;
     if (finalizer != NULL && asyncgen->m_closed == false) {
-        /* Save the current exception, if any. */
-        FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
+        // Save the current exception, if any.
+        FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
         PyObject *res = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, finalizer, (PyObject *)asyncgen);
 
@@ -1003,11 +960,11 @@ static void Nuitka_Asyncgen_tp_dealloc(struct Nuitka_AsyncgenObject *asyncgen) {
             Py_DECREF(res);
         }
 
-        RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
         return;
     }
 
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     bool close_result = _Nuitka_Asyncgen_close(tstate, asyncgen);
 
@@ -1046,7 +1003,7 @@ static void Nuitka_Asyncgen_tp_dealloc(struct Nuitka_AsyncgenObject *asyncgen) {
     /* Put the object into free list or release to GC */
     releaseToFreeList(free_list_asyncgens, asyncgen, MAX_ASYNCGEN_FREE_LIST_COUNT);
 
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
 static PyObject *Nuitka_Asyncgen_tp_repr(struct Nuitka_AsyncgenObject *asyncgen) {
@@ -1059,7 +1016,7 @@ static PyObject *Nuitka_Asyncgen_tp_repr(struct Nuitka_AsyncgenObject *asyncgen)
 static int Nuitka_Asyncgen_tp_traverse(struct Nuitka_AsyncgenObject *asyncgen, visitproc visit, void *arg) {
     CHECK_OBJECT(asyncgen);
 
-    Py_VISIT(asyncgen->m_yieldfrom);
+    Py_VISIT(asyncgen->m_yield_from);
 
     for (Py_ssize_t i = 0; i < asyncgen->m_closure_given; i++) {
         Py_VISIT(asyncgen->m_closure[i]);
@@ -1091,7 +1048,7 @@ static PyAsyncMethods Nuitka_Asyncgen_as_async = {
 
 // TODO: Set "__doc__" automatically for method clones of compiled types from
 // the documentation of built-in original type.
-static PyGetSetDef Nuitka_Asyncgen_getsetlist[] = {
+static PyGetSetDef Nuitka_Asyncgen_tp_getset[] = {
     {(char *)"__name__", (getter)Nuitka_Asyncgen_get_name, (setter)Nuitka_Asyncgen_set_name, NULL},
     {(char *)"__qualname__", (getter)Nuitka_Asyncgen_get_qualname, (setter)Nuitka_Asyncgen_set_qualname, NULL},
     {(char *)"ag_await", (getter)Nuitka_Asyncgen_get_ag_await, (setter)NULL, NULL},
@@ -1136,7 +1093,7 @@ PyTypeObject Nuitka_Asyncgen_Type = {
     0,                                                                  // tp_iternext
     Nuitka_Asyncgen_methods,                                            // tp_methods
     Nuitka_Asyncgen_members,                                            // tp_members
-    Nuitka_Asyncgen_getsetlist,                                         // tp_getset
+    Nuitka_Asyncgen_tp_getset,                                          // tp_getset
     0,                                                                  // tp_base
     0,                                                                  // tp_dict
     0,                                                                  // tp_descr_get
@@ -1195,7 +1152,7 @@ PyObject *Nuitka_Asyncgen_New(asyncgen_code code, PyObject *module, PyObject *na
     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;
@@ -1393,7 +1350,13 @@ struct _PyAsyncGenWrappedValue {
         PyObject *agw_val;
 };
 
+#if PYTHON_VERSION < 0x3d0
 #define _PyAsyncGenWrappedValue_CheckExact(o) (Py_TYPE(o) == &_PyAsyncGenWrappedValue_Type)
+#else
+static PyTypeObject *Nuitka_PyAsyncGenWrappedValue_Type = NULL;
+
+#define _PyAsyncGenWrappedValue_CheckExact(o) (Py_TYPE(o) == Nuitka_PyAsyncGenWrappedValue_Type)
+#endif
 
 static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen,
                                                PyObject *result) {
@@ -1419,7 +1382,7 @@ static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nui
 
     if (_PyAsyncGenWrappedValue_CheckExact(result)) {
         /* async yield */
-        _PyGen_SetStopIterationValue(((struct _PyAsyncGenWrappedValue *)result)->agw_val);
+        Nuitka_SetStopIterationValue(tstate, ((struct _PyAsyncGenWrappedValue *)result)->agw_val);
 
         Py_DECREF(result);
 
@@ -1429,7 +1392,7 @@ static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nui
         return NULL;
     } else if (Nuitka_AsyncgenWrappedValue_CheckExact(result)) {
         /* async yield */
-        _PyGen_SetStopIterationValue(((struct Nuitka_AsyncgenWrappedValueObject *)result)->m_value);
+        Nuitka_SetStopIterationValue(tstate, ((struct Nuitka_AsyncgenWrappedValueObject *)result)->m_value);
 
         Py_DECREF(result);
 
@@ -1530,7 +1493,11 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 #endif
 
     Py_INCREF(arg);
-    PyObject *result = _Nuitka_Asyncgen_send(tstate, asyncgen_asend->m_gen, arg, false, NULL, NULL, NULL);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PyObject *result = _Nuitka_Asyncgen_send(tstate, asyncgen_asend->m_gen, arg, false, &exception_state);
 
 #if _DEBUG_ASYNCGEN
     PRINT_STRING("Returned from _Nuitka_Asyncgen_send\n");
@@ -1625,11 +1592,10 @@ static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *a
 }
 
 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) {
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
 #endif
@@ -1639,8 +1605,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
         return NULL;
     }
 
-    PyObject *result =
-        _Nuitka_Asyncgen_throw2(tstate, asyncgen_asend->m_gen, false, exception_type, exception_value, exception_tb);
+    PyObject *result = _Nuitka_Asyncgen_throw2(tstate, asyncgen_asend->m_gen, false, exception_state);
 
     // TODO: This might not be all that necessary as this is not directly outside facing,
     // but there were tests failing when this was not the specific value.
@@ -1679,7 +1644,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
 static PyObject *Nuitka_AsyncgenAsend_close(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *args) {
     asyncgen_asend->m_state = AWAITABLE_STATE_CLOSED;
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -1914,10 +1879,12 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
         if (asyncgen_athrow->m_args == NULL) {
             asyncgen->m_closed = true;
 
-            Py_INCREF(PyExc_GeneratorExit);
+            struct Nuitka_ExceptionPreservationItem exception_state;
+            SET_EXCEPTION_PRESERVATION_STATE_FROM_ARGS(tstate, &exception_state, PyExc_GeneratorExit, NULL, NULL);
+
             retval = _Nuitka_Asyncgen_throw2(tstate, asyncgen,
                                              1, /* Do not close generator when PyExc_GeneratorExit is passed */
-                                             PyExc_GeneratorExit, NULL, NULL);
+                                             &exception_state);
 
             if (retval) {
                 if (_PyAsyncGenWrappedValue_CheckExact(retval) || Nuitka_AsyncgenWrappedValue_CheckExact(retval)) {
@@ -1944,13 +1911,15 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
             }
 
             // 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;
+            }
 
             retval = _Nuitka_Asyncgen_throw2(tstate, asyncgen,
                                              0, /* Do not close generator when PyExc_GeneratorExit is passed */
-                                             exception_type, exception_value, exception_tb);
+                                             &exception_state);
 
             retval = _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen, retval);
         }
@@ -1964,7 +1933,10 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
 
     assert(asyncgen_athrow->m_state == AWAITABLE_STATE_ITER);
 
-    retval = _Nuitka_Asyncgen_send(tstate, asyncgen, arg, false, NULL, NULL, NULL);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    retval = _Nuitka_Asyncgen_send(tstate, asyncgen, arg, false, &exception_state);
 
     if (asyncgen_athrow->m_args) {
         return _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen, retval);
@@ -2079,7 +2051,7 @@ static PyObject *Nuitka_AsyncgenAthrow_tp_iternext(struct Nuitka_AsyncgenAthrowO
 static PyObject *Nuitka_AsyncgenAthrow_close(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
     asyncgen_athrow->m_state = AWAITABLE_STATE_CLOSED;
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -2210,4 +2182,26 @@ static void _initCompiledAsyncgenTypes(void) {
     Nuitka_PyType_Ready(&Nuitka_AsyncgenAsend_Type, NULL, true, false, true, true, false);
     Nuitka_PyType_Ready(&Nuitka_AsyncgenAthrow_Type, NULL, true, false, true, true, false);
     Nuitka_PyType_Ready(&Nuitka_AsyncgenValueWrapper_Type, NULL, false, false, false, false, false);
+
+#if PYTHON_VERSION >= 0x3d0
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *asyncgen_wrapper_object = _PyIntrinsics_UnaryFunctions[INTRINSIC_ASYNC_GEN_WRAP].func(tstate, Py_None);
+    Nuitka_PyAsyncGenWrappedValue_Type = Py_TYPE(asyncgen_wrapper_object);
+    Py_DECREF(asyncgen_wrapper_object);
+#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.