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

nuitka/build/static_src/CompiledGeneratorType.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 Generators.
  *
  * Unlike in CPython, we have one type for just generators, this doesn't do coroutines
@@ -28,6 +13,13 @@
 /* This file is included from another C file, help IDEs to still parse it on its own. */
 #ifdef __IDE_ONLY__
 #include "nuitka/prelude.h"
+#include <structmember.h>
+#endif
+
+#if _DEBUG_REFCOUNTS
+int count_active_Nuitka_Generator_Type;
+int count_allocated_Nuitka_Generator_Type;
+int count_released_Nuitka_Generator_Type;
 #endif
 
 // In a separate file, code to interact with uncompiled generators, that does
@@ -118,13 +110,15 @@ static void Nuitka_MarkGeneratorAsNotRunning(struct Nuitka_GeneratorObject *gene
 }
 
 static PyObject *Nuitka_Generator_tp_repr(struct Nuitka_GeneratorObject *generator) {
-    return Nuitka_String_FromFormat("<compiled_generator object %s at %p>",
-#if PYTHON_VERSION < 0x350
-                                    Nuitka_String_AsString(generator->m_name),
+#if PYTHON_VERSION < 0x300
+    return Nuitka_String_FromFormat("<compiled_generator object %s at %p>", Nuitka_String_AsString(generator->m_name),
+                                    generator);
+#elif PYTHON_VERSION < 0x350
+    return Nuitka_String_FromFormat("<compiled_generator object %U at %p>", generator->m_name, generator);
+
 #else
-                                    Nuitka_String_AsString(generator->m_qualname),
+    return Nuitka_String_FromFormat("<compiled_generator object %U at %p>", generator->m_qualname, generator);
 #endif
-                                    generator);
 }
 
 static long Nuitka_Generator_tp_traverse(struct Nuitka_GeneratorObject *generator, visitproc visit, void *arg) {
@@ -132,7 +126,7 @@ static long Nuitka_Generator_tp_traverse(struct Nuitka_GeneratorObject *generato
 
     // TODO: Identify the impact of not visiting owned objects like module.
 #if PYTHON_VERSION >= 0x300
-    Py_VISIT(generator->m_yieldfrom);
+    Py_VISIT(generator->m_yield_from);
 #endif
 
     for (Py_ssize_t i = 0; i < generator->m_closure_given; i++) {
@@ -159,12 +153,16 @@ static void Nuitka_Generator_release_closure(struct Nuitka_GeneratorObject *gene
 static PyObject *ERROR_GET_STOP_ITERATION_VALUE(PyThreadState *tstate) {
     assert(PyErr_ExceptionMatches(PyExc_StopIteration));
 
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
-    Py_DECREF(exception_type);
-    Py_XDECREF(exception_tb);
+#if PYTHON_VERSION < 0x3c0
+    Py_DECREF(saved_exception_state.exception_type);
+    Py_XDECREF(saved_exception_state.exception_tb);
+#endif
+
+    // We own a reference, and we mean to return it.
+    PyObject *exception_value = saved_exception_state.exception_value;
 
     PyObject *value = NULL;
 
@@ -179,27 +177,45 @@ static PyObject *ERROR_GET_STOP_ITERATION_VALUE(PyThreadState *tstate) {
     }
 
     if (value == NULL) {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         value = Py_None;
     }
 
     return value;
 }
 
+static PyObject *Nuitka_CallGeneratorThrowMethod(PyObject *throw_method,
+                                                 struct Nuitka_ExceptionPreservationItem *exception_state) {
+
+    // TODO: Faster call code should be used.
+
+#if PYTHON_VERSION < 0x3c0
+    PyObject *result =
+        PyObject_CallFunctionObjArgs(throw_method, exception_state->exception_type, exception_state->exception_value,
+                                     exception_state->exception_tb, NULL);
+
+    return result;
+#else
+    // For Python 3.12 or higher, we don't create the type and tb args, code was
+    // always supposed to handle single argument forms and is now.
+    PyObject *result = PyObject_CallFunctionObjArgs(throw_method, exception_state->exception_value, NULL);
+
+    return result;
+#endif
+}
+
 static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
-                                          PyObject *exception_type, PyObject *exception_value,
-                                          PyTracebackObject *exception_tb);
+                                          struct Nuitka_ExceptionPreservationItem *exception_state);
 #if PYTHON_VERSION >= 0x350
 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);
 #endif
 
-static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObject *value, PyObject *exception_type,
-                                                  PyObject *exception_value, PyTracebackObject *exception_tb) {
+static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObject *value,
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state) {
     // The yielding generator is being closed, but we also are tasked to
     // immediately close the currently running sub-generator.
-    if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+    if (EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
         PyObject *close_method = PyObject_GetAttr(value, const_str_plain_close);
 
         if (close_method) {
@@ -208,9 +224,7 @@ static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObjec
 
             if (unlikely(close_value == NULL)) {
                 // Release exception, we are done with it, raising the one from close instead.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                 return NULL;
             }
@@ -225,7 +239,7 @@ static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObjec
         }
 
         // Transfer exception ownership to published.
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
         return NULL;
     }
@@ -239,8 +253,7 @@ static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObjec
         PyGenObject *gen = (PyGenObject *)value;
 
         // Handing exception ownership over.
-        PyObject *result =
-            Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_type, exception_value, exception_tb);
+        PyObject *result = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_state);
 
         return result;
     }
@@ -249,60 +262,55 @@ static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObjec
     if (Nuitka_Generator_Check(value)) {
         struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)value);
 
-        return _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
+        return _Nuitka_Generator_throw2(tstate, gen, exception_state);
     }
 
 #if PYTHON_VERSION >= 0x350
     if (Nuitka_Coroutine_Check(value)) {
         struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)value);
         // Handing exception ownership over.
-        return _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+        return _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
     }
 
     if (Nuitka_CoroutineWrapper_Check(value)) {
         struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineWrapperObject *)value)->m_coroutine;
         // Handing exception ownership over.
-        return _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+        return _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
     }
 #endif
 
     PyObject *throw_method = PyObject_GetAttr(value, const_str_plain_throw);
 
     if (throw_method) {
-        PyObject *result =
-            PyObject_CallFunctionObjArgs(throw_method, exception_type, exception_value, exception_tb, NULL);
+        PyObject *result = Nuitka_CallGeneratorThrowMethod(throw_method, exception_state);
         Py_DECREF(throw_method);
 
         // Releasing exception we own.
-        Py_DECREF(exception_type);
-        Py_XDECREF(exception_value);
-        Py_XDECREF(exception_tb);
+        RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
         return result;
     } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, GET_ERROR_OCCURRED(tstate), PyExc_AttributeError)) {
         // Restoring the exception we own, to be released when handling it.
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
         return NULL;
     } else {
         assert(HAS_ERROR_OCCURRED(tstate));
 
         // Releasing exception we own.
-        Py_DECREF(exception_type);
-        Py_XDECREF(exception_value);
-        Py_XDECREF(exception_tb);
+        RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
         return NULL;
     }
 }
 
 static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
-                                                PyObject *yieldfrom, PyObject *send_value) {
+                                                PyObject *yield_from, PyObject *send_value) {
     // 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);
     assert(send_value != NULL || HAS_ERROR_OCCURRED(tstate));
 
     PyObject *retval;
@@ -315,14 +323,13 @@ static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nu
     PRINT_NEW_LINE();
 #endif
 
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
 
     // Exception, was thrown into us, need to send that to sub-generator.
-    if (exception_type != NULL) {
+    if (HAS_EXCEPTION_STATE(&exception_state)) {
         // Passing ownership of exception fetch to it.
-        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)) {
@@ -335,23 +342,23 @@ static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nu
                 return NULL;
             }
         }
-    } else if (PyGen_CheckExact(yieldfrom)) {
-        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yieldfrom, Py_None);
+    } else if (PyGen_CheckExact(yield_from)) {
+        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yield_from, Py_None);
     }
 #if PYTHON_VERSION >= 0x350
-    else if (PyCoro_CheckExact(yieldfrom)) {
-        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yieldfrom, Py_None);
+    else if (PyCoro_CheckExact(yield_from)) {
+        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yield_from, Py_None);
     }
 #endif
-    else if (send_value == Py_None && Py_TYPE(yieldfrom)->tp_iternext != NULL) {
-        retval = Py_TYPE(yieldfrom)->tp_iternext(yieldfrom);
+    else if (send_value == Py_None && Py_TYPE(yield_from)->tp_iternext != NULL) {
+        retval = Py_TYPE(yield_from)->tp_iternext(yield_from);
     } else {
-        // Bug compatibility here, before 3.3 tuples were unrolled in calls, which is what
+        // Bug compatibility here, before Python3 tuples were unrolled in calls, which is what
         // PyObject_CallMethod does.
-#if PYTHON_VERSION >= 0x340
-        retval = PyObject_CallMethodObjArgs(yieldfrom, const_str_plain_send, send_value, NULL);
+#if PYTHON_VERSION >= 0x300
+        retval = PyObject_CallMethodObjArgs(yield_from, const_str_plain_send, send_value, NULL);
 #else
-        retval = PyObject_CallMethod(yieldfrom, (char *)"send", (char *)"O", send_value);
+        retval = PyObject_CallMethod(yield_from, (char *)"send", (char *)"O", send_value);
 #endif
     }
 
@@ -360,7 +367,7 @@ static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nu
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
         if (error == NULL) {
-            Py_INCREF(Py_None);
+            Py_INCREF_IMMORTAL(Py_None);
             generator->m_returned = Py_None;
         } else if (likely(EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration))) {
             // The sub-generator has given an exception. In case of
@@ -382,15 +389,15 @@ static PyObject *Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nui
     CHECK_OBJECT(generator);
     CHECK_OBJECT_X(send_value);
 
-    PyObject *yieldfrom = generator->m_yieldfrom;
-    CHECK_OBJECT(yieldfrom);
+    PyObject *yield_from = generator->m_yield_from;
+    CHECK_OBJECT(yield_from);
 
     // Need to make it unaccessible while using it.
-    generator->m_yieldfrom = NULL;
-    PyObject *yielded = _Nuitka_YieldFromGeneratorCore(tstate, generator, yieldfrom, send_value);
+    generator->m_yield_from = NULL;
+    PyObject *yielded = _Nuitka_YieldFromGeneratorCore(tstate, generator, yield_from, send_value);
 
     if (yielded == NULL) {
-        Py_DECREF(yieldfrom);
+        Py_DECREF(yield_from);
 
         if (generator->m_returned != NULL) {
             PyObject *yield_from_result = generator->m_returned;
@@ -403,7 +410,7 @@ static PyObject *Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nui
         }
 
     } else {
-        generator->m_yieldfrom = yieldfrom;
+        generator->m_yield_from = yield_from;
     }
 
     return yielded;
@@ -414,7 +421,7 @@ static PyObject *Nuitka_YieldFromGeneratorNext(PyThreadState *tstate, struct Nui
 
     // Coroutines are already perfect for yielding from.
 #if PYTHON_VERSION >= 0x350
-    if (PyCoro_CheckExact(generator->m_yieldfrom) || Nuitka_Coroutine_Check(generator->m_yieldfrom)) {
+    if (PyCoro_CheckExact(generator->m_yield_from) || Nuitka_Coroutine_Check(generator->m_yield_from)) {
         if (unlikely((generator->m_code_object->co_flags & CO_ITERABLE_COROUTINE) == 0)) {
             SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
                                             "cannot 'yield from' a coroutine object in a non-coroutine generator");
@@ -422,10 +429,10 @@ static PyObject *Nuitka_YieldFromGeneratorNext(PyThreadState *tstate, struct Nui
     } else
 #endif
     {
-        PyObject *new_iterator = MAKE_ITERATOR(tstate, generator->m_yieldfrom);
+        PyObject *new_iterator = MAKE_ITERATOR(tstate, generator->m_yield_from);
         if (new_iterator != NULL) {
-            Py_DECREF(generator->m_yieldfrom);
-            generator->m_yieldfrom = new_iterator;
+            Py_DECREF(generator->m_yield_from);
+            generator->m_yield_from = new_iterator;
         }
     }
 
@@ -451,35 +458,60 @@ static void _Nuitka_GeneratorPopFrame(PyThreadState *tstate, Nuitka_ThreadStateF
 #if PYTHON_VERSION < 0x3b0
     tstate->frame = return_frame;
 #else
-    tstate->cframe->current_frame = return_frame;
+    CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = return_frame;
 #endif
 
     PRINT_TOP_FRAME("Generator pop exit gives top frame:");
 }
 
+#if PYTHON_VERSION >= 0x350
+static void RAISE_RUNTIME_ERROR_RAISED_STOP_ITERATION(PyThreadState *tstate, char const *message) {
+
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+
+#if PYTHON_VERSION < 0x3c0
+    NORMALIZE_EXCEPTION(tstate, &saved_exception_state.exception_type, &saved_exception_state.exception_value,
+                        &saved_exception_state.exception_tb);
+#endif
+
+    struct Nuitka_ExceptionPreservationItem new_exception_state;
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_STR(tstate, &new_exception_state, PyExc_RuntimeError, message);
+
+#if PYTHON_VERSION < 0x3c0
+    NORMALIZE_EXCEPTION(tstate, &new_exception_state.exception_type, &new_exception_state.exception_value,
+                        &new_exception_state.exception_tb);
+#endif
+
+    Py_INCREF(saved_exception_state.exception_value);
+    RAISE_EXCEPTION_WITH_CAUSE_STATE(tstate, &new_exception_state, saved_exception_state.exception_value);
+
+    Py_INCREF(saved_exception_state.exception_value);
+    PyException_SetContext(new_exception_state.exception_value, saved_exception_state.exception_value);
+
+    RELEASE_ERROR_OCCURRED_STATE_X(&saved_exception_state);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &new_exception_state);
+}
+#endif
+
 static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
-                                        PyObject *value, PyObject *exception_type, PyObject *exception_value,
-                                        PyTracebackObject *exception_tb) {
+                                        PyObject *value, struct Nuitka_ExceptionPreservationItem *exception_state) {
     CHECK_OBJECT(generator);
     assert(Nuitka_Generator_Check((PyObject *)generator));
-    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);
     assert(PyThreadState_GET() == tstate);
 
 #if _DEBUG_GENERATOR
     PRINT_GENERATOR_STATUS("Enter", generator);
     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 (generator->m_status != status_Finished) {
@@ -521,15 +553,15 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
         Nuitka_MarkGeneratorAsRunning(generator);
 
         // Check for thrown exception, publish it to the generator 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_GENERATOR
-        PRINT_GENERATOR_STATUS("Switching to coroutine", generator);
+        PRINT_GENERATOR_STATUS("Switching to generator", generator);
         PRINT_COROUTINE_VALUE("value", value);
         PRINT_CURRENT_EXCEPTION();
         PRINT_NEW_LINE();
@@ -539,7 +571,7 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
         PyObject *yielded;
 
 #if PYTHON_VERSION >= 0x300
-        if (generator->m_yieldfrom == NULL) {
+        if (generator->m_yield_from == NULL) {
             yielded = ((generator_code)generator->m_code)(tstate, generator, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -552,9 +584,9 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
         assert(PyThreadState_GET() == tstate);
 
 #if PYTHON_VERSION >= 0x300
-        // If the generator returns with m_yieldfrom set, it wants us to yield
+        // If the generator returns with m_yield_from set, it wants us to yield
         // from that value from now on.
-        while (yielded == NULL && generator->m_yieldfrom != NULL) {
+        while (yielded == NULL && generator->m_yield_from != NULL) {
             yielded = Nuitka_YieldFromGeneratorNext(tstate, generator);
         }
 #endif
@@ -567,7 +599,9 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
             // assert(tstate->frame == &generator->m_frame->m_frame);
             assertFrameObject(generator->m_frame);
 
-            Py_CLEAR(generator->m_frame->m_frame.f_back);
+            if (generator->m_frame->m_frame.f_back) {
+                Py_CLEAR(generator->m_frame->m_frame.f_back);
+            }
         }
 
         // Return back to the frame that called us.
@@ -589,7 +623,7 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
             Nuitka_MarkGeneratorAsFinished(generator);
 
             if (generator->m_frame != NULL) {
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
                 Nuitka_SetFrameGenerator(generator->m_frame, NULL);
 #endif
                 Py_DECREF(generator->m_frame);
@@ -612,30 +646,7 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
                 generator->m_code_object->co_flags & CO_FUTURE_GENERATOR_STOP &&
 #endif
                 GET_ERROR_OCCURRED(tstate) == 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);
-
-                SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "generator 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, "generator raised StopIteration");
 
                 return NULL;
             }
@@ -697,9 +708,9 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
                 tstate->exc_value = Py_None;
                 tstate->exc_traceback = (PyObject *)Py_None;
 
-                Py_INCREF(Py_None);
-                Py_INCREF(Py_None);
-                Py_INCREF(Py_None);
+                Py_INCREF_IMMORTAL(Py_None);
+                Py_INCREF_IMMORTAL(Py_None);
+                Py_INCREF_IMMORTAL(Py_None);
 
                 Py_XDECREF(old_type);
                 Py_XDECREF(old_value);
@@ -725,9 +736,11 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
 }
 
 static PyObject *Nuitka_Generator_send(struct Nuitka_GeneratorObject *generator, PyObject *value) {
+    CHECK_OBJECT(value);
+
     PyThreadState *tstate = PyThreadState_GET();
 
-    if (generator->m_status == status_Unused && value != NULL && value != Py_None) {
+    if (generator->m_status == status_Unused && value != Py_None) {
         // Buggy CPython 3.10 refuses to allow later usage.
 #if PYTHON_VERSION >= 0x3a0 && PYTHON_VERSION < 0x3a2
         Nuitka_MarkGeneratorAsFinished(generator);
@@ -740,7 +753,11 @@ static PyObject *Nuitka_Generator_send(struct Nuitka_GeneratorObject *generator,
 
     // We need to transfer ownership of the sent value.
     Py_INCREF(value);
-    PyObject *result = _Nuitka_Generator_send(tstate, generator, value, NULL, NULL, NULL);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PyObject *result = _Nuitka_Generator_send(tstate, generator, value, &exception_state);
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
@@ -754,15 +771,23 @@ static PyObject *Nuitka_Generator_send(struct Nuitka_GeneratorObject *generator,
 static PyObject *Nuitka_Generator_tp_iternext(struct Nuitka_GeneratorObject *generator) {
     PyThreadState *tstate = PyThreadState_GET();
 
-    Py_INCREF(Py_None);
-    return _Nuitka_Generator_send(tstate, generator, Py_None, NULL, NULL, NULL);
+    Py_INCREF_IMMORTAL(Py_None);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    return _Nuitka_Generator_send(tstate, generator, Py_None, &exception_state);
 }
 
 /* Our own qiter interface, which is for quicker simple loop style iteration,
    that does not send anything in. */
 PyObject *Nuitka_Generator_qiter(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator, bool *finished) {
-    Py_INCREF(Py_None);
-    PyObject *result = _Nuitka_Generator_send(tstate, generator, Py_None, NULL, NULL, NULL);
+    Py_INCREF_IMMORTAL(Py_None);
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    INIT_ERROR_OCCURRED_STATE(&exception_state);
+
+    PyObject *result = _Nuitka_Generator_send(tstate, generator, Py_None, &exception_state);
 
     if (result == NULL) {
         if (unlikely(!CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate))) {
@@ -798,9 +823,10 @@ static bool _Nuitka_Generator_close(PyThreadState *tstate, struct Nuitka_Generat
     CHECK_OBJECT(generator);
 
     if (generator->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_Generator_send(tstate, generator, NULL, PyExc_GeneratorExit, NULL, NULL);
+        PyObject *result = _Nuitka_Generator_send(tstate, generator, NULL, &exception_state);
 
         if (unlikely(result)) {
             Py_DECREF(result);
@@ -831,20 +857,15 @@ static PyObject *Nuitka_Generator_close(struct Nuitka_GeneratorObject *generator
     if (unlikely(r == false)) {
         return NULL;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
 
-// Shared code for checking a thrown exception, coroutines, asyncgen, uncompiled ones do this too.
-static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                           PyTracebackObject **exception_tb) {
-    CHECK_OBJECT(*exception_type);
-    CHECK_OBJECT_X(*exception_value);
-    CHECK_OBJECT_X(*exception_tb);
-
+#if PYTHON_VERSION >= 0x3c0
+static bool _Nuitka_Generator_check_throw_args(PyThreadState *tstate, PyObject **exception_type,
+                                               PyObject **exception_value, PyTracebackObject **exception_tb) {
     if (*exception_tb == (PyTracebackObject *)Py_None) {
-        Py_DECREF(*exception_tb);
         *exception_tb = NULL;
     } else if (*exception_tb != NULL && !PyTraceBack_Check(*exception_tb)) {
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "throw() third argument must be a traceback object");
@@ -852,7 +873,6 @@ static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exc
     }
 
     if (PyExceptionClass_Check(*exception_type)) {
-        // TODO: Must not / need not normalize here?
         NORMALIZE_EXCEPTION(tstate, exception_type, exception_value, exception_tb);
     } else if (PyExceptionInstance_Check(*exception_type)) {
         if (*exception_value != NULL && *exception_value != Py_None) {
@@ -862,10 +882,8 @@ static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exc
         }
 
         // Release old None value and replace it with the object, then set the exception type
-        // from the class.
-        Py_XDECREF(*exception_value);
+        // from the class. The "None" is known immortal here and needs no refcount correction.
         *exception_value = *exception_type;
-
         *exception_type = PyExceptionInstance_Class(*exception_type);
         Py_INCREF(*exception_type);
     } else {
@@ -883,10 +901,95 @@ static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exc
     return true;
 
 failed_throw:
+
+    return false;
+}
+#endif
+
+static bool _Nuitka_Generator_make_throw_exception_state(PyThreadState *tstate,
+                                                         struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                         PyObject *exception_type, PyObject *exception_value,
+                                                         PyTracebackObject *exception_tb) {
+
+#if PYTHON_VERSION >= 0x3c0
+    Py_INCREF(exception_type);
+    Py_XINCREF(exception_value);
+    Py_XINCREF(exception_tb);
+
+    if (_Nuitka_Generator_check_throw_args(tstate, &exception_type, &exception_value, &exception_tb) == false) {
+        Py_DECREF(exception_type);
+        Py_XDECREF(exception_value);
+        Py_XDECREF(exception_tb);
+
+        return false;
+    }
+#endif
+
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_ARGS(tstate, exception_state, exception_type, exception_value, exception_tb);
+
+#if PYTHON_VERSION >= 0x3c0
+    Py_DECREF(exception_type);
+    Py_XDECREF(exception_value);
+    Py_XDECREF(exception_tb);
+#endif
+
+    return true;
+}
+
+// Shared code for checking a thrown exception, coroutines, asyncgen, uncompiled
+// ones do this too. For pre-3.12, the checking needs to be done late, for 3.12
+// early, so it's a separate function.
+static bool _Nuitka_Generator_check_throw(PyThreadState *tstate,
+                                          struct Nuitka_ExceptionPreservationItem *exception_state) {
+    CHECK_EXCEPTION_STATE(exception_state);
+
+#if PYTHON_VERSION < 0x3c0
+    if (exception_state->exception_tb == (PyTracebackObject *)Py_None) {
+        Py_DECREF(exception_state->exception_tb);
+        exception_state->exception_tb = NULL;
+    } else if (exception_state->exception_tb != NULL && !PyTraceBack_Check(exception_state->exception_tb)) {
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "throw() third argument must be a traceback object");
+        goto failed_throw;
+    }
+
+    if (PyExceptionClass_Check(exception_state->exception_type)) {
+        // TODO: Must not / need not normalize here?
+        NORMALIZE_EXCEPTION(tstate, &exception_state->exception_type, &exception_state->exception_value,
+                            &exception_state->exception_tb);
+    } else if (PyExceptionInstance_Check(exception_state->exception_type)) {
+        if (exception_state->exception_value != NULL && exception_state->exception_value != Py_None) {
+            SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
+                                            "instance exception may not have a separate value");
+            goto failed_throw;
+        }
+
+        // Release old None value and replace it with the object, then set the exception type
+        // from the class.
+        Py_XDECREF(exception_state->exception_value);
+        exception_state->exception_value = exception_state->exception_type;
+
+        exception_state->exception_type = PyExceptionInstance_Class(exception_state->exception_type);
+        Py_INCREF(exception_state->exception_type);
+    } else {
+#if PYTHON_VERSION < 0x300
+        PyErr_Format(PyExc_TypeError, "exceptions must be classes, or instances, not %s",
+                     Py_TYPE(exception_state->exception_type)->tp_name);
+#else
+        PyErr_Format(PyExc_TypeError, "exceptions must be classes or instances deriving from BaseException, not %s",
+                     Py_TYPE(exception_state->exception_type)->tp_name);
+#endif
+
+        goto failed_throw;
+    }
+
+#endif
+    return true;
+
+#if PYTHON_VERSION < 0x3c0
+failed_throw:
+#endif
     // 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 false;
 }
@@ -902,49 +1005,49 @@ static bool _Nuitka_Asyncgen_close(PyThreadState *tstate, struct Nuitka_Asyncgen
 #endif
 
 // Note: This is also used for coroutines and asyncgen
-static bool Nuitka_gen_close_iter(PyThreadState *tstate, PyObject *yieldfrom) {
+static bool Nuitka_gen_close_iter(PyThreadState *tstate, PyObject *yield_from) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_gen_close_iter: Enter\n");
 #endif
 
-    CHECK_OBJECT(yieldfrom);
+    CHECK_OBJECT(yield_from);
 
-    // TODO: Could specialize depending in yieldfrom type for performance. Many
+    // TODO: Could specialize depending in yield_from type for performance. Many
     // times these will be our own ones, or known ones like uncompiled
     // generators.
-    if (Nuitka_Generator_Check(yieldfrom)) {
+    if (Nuitka_Generator_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Generator_close\n");
 #endif
-        return _Nuitka_Generator_close(tstate, (struct Nuitka_GeneratorObject *)yieldfrom);
+        return _Nuitka_Generator_close(tstate, (struct Nuitka_GeneratorObject *)yield_from);
     }
 
 #if PYTHON_VERSION >= 0x350
-    if (Nuitka_Coroutine_Check(yieldfrom)) {
+    if (Nuitka_Coroutine_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Coroutine_close\n");
 #endif
-        return _Nuitka_Coroutine_close(tstate, (struct Nuitka_CoroutineObject *)yieldfrom);
+        return _Nuitka_Coroutine_close(tstate, (struct Nuitka_CoroutineObject *)yield_from);
     }
 #endif
 
 #if PYTHON_VERSION >= 0x360
-    if (Nuitka_Asyncgen_Check(yieldfrom)) {
+    if (Nuitka_Asyncgen_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Asyncgen_close\n");
 #endif
-        return _Nuitka_Asyncgen_close(tstate, (struct Nuitka_AsyncgenObject *)yieldfrom);
+        return _Nuitka_Asyncgen_close(tstate, (struct Nuitka_AsyncgenObject *)yield_from);
     }
 #endif
 
-    PyObject *meth = PyObject_GetAttr(yieldfrom, const_str_plain_close);
+    PyObject *meth = PyObject_GetAttr(yield_from, const_str_plain_close);
 
     if (unlikely(meth == NULL)) {
         if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) {
 #if _DEBUG_GENERATOR
             PRINT_STRING("Nuitka_gen_close_iter: Strange error while looking up close method.\n");
 #endif
-            PyErr_WriteUnraisable(yieldfrom);
+            PyErr_WriteUnraisable(yield_from);
         }
 
         CLEAR_ERROR_OCCURRED(tstate);
@@ -980,113 +1083,105 @@ static bool Nuitka_gen_close_iter(PyThreadState *tstate, PyObject *yieldfrom) {
 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 PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
-                                          PyObject *exception_type, PyObject *exception_value,
-                                          PyTracebackObject *exception_tb) {
+                                          struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_GENERATOR
     PRINT_GENERATOR_STATUS("Enter", generator);
-    PRINT_COROUTINE_VALUE("yieldfrom", generator->m_yieldfrom);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_COROUTINE_VALUE("yield_from", generator->m_yield_from);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
     CHECK_OBJECT(generator);
     assert(Nuitka_Generator_Check((PyObject *)generator));
-    CHECK_OBJECT(exception_type);
-    CHECK_OBJECT_X(exception_value);
-    CHECK_OBJECT_X(exception_tb);
+    CHECK_EXCEPTION_STATE(exception_state);
 
 #if PYTHON_VERSION >= 0x300
-    if (generator->m_yieldfrom != NULL) {
-        if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+    if (generator->m_yield_from != NULL) {
+        if (EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
             // Generators need to close the yield_from.
             Nuitka_MarkGeneratorAsRunning(generator);
-            bool res = Nuitka_gen_close_iter(tstate, generator->m_yieldfrom);
+            bool res = Nuitka_gen_close_iter(tstate, generator->m_yield_from);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 
             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_Generator_send".
-            return _Nuitka_Generator_send(tstate, generator, NULL, exception_type, exception_value, exception_tb);
+            return _Nuitka_Generator_send(tstate, generator, NULL, exception_state);
         }
 
         PyObject *ret;
 
 #if _DEBUG_GENERATOR
         PRINT_GENERATOR_STATUS("Passing to yielded from", generator);
-        PRINT_COROUTINE_VALUE("m_yieldfrom", generator->m_yieldfrom);
+        PRINT_COROUTINE_VALUE("m_yield_from", generator->m_yield_from);
         PRINT_NEW_LINE();
 #endif
 
-        if (Nuitka_Generator_Check(generator->m_yieldfrom)) {
-            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)generator->m_yieldfrom);
+        if (Nuitka_Generator_Check(generator->m_yield_from)) {
+            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)generator->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Generator_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Generator_throw2(tstate, gen, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        } else if (PyGen_CheckExact(generator->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)generator->m_yieldfrom;
+        } else if (PyGen_CheckExact(generator->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)generator->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_type, exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #endif
 #if PYTHON_VERSION >= 0x350
-        } else if (Nuitka_Coroutine_Check(generator->m_yieldfrom)) {
-            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)generator->m_yieldfrom);
+        } else if (Nuitka_Coroutine_Check(generator->m_yield_from)) {
+            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)generator->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
-        } else if (Nuitka_CoroutineWrapper_Check(generator->m_yieldfrom)) {
+        } else if (Nuitka_CoroutineWrapper_Check(generator->m_yield_from)) {
             struct Nuitka_CoroutineObject *coro =
-                ((struct Nuitka_CoroutineWrapperObject *)generator->m_yieldfrom)->m_coroutine;
+                ((struct Nuitka_CoroutineWrapperObject *)generator->m_yield_from)->m_coroutine;
 
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        } else if (PyCoro_CheckExact(generator->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)generator->m_yieldfrom;
+        } else if (PyCoro_CheckExact(generator->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)generator->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_type, exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, gen, 1, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #endif
 #if PYTHON_VERSION >= 0x360
-        } else if (Nuitka_AsyncgenAsend_Check(generator->m_yieldfrom)) {
+        } else if (Nuitka_AsyncgenAsend_Check(generator->m_yield_from)) {
             struct Nuitka_AsyncgenAsendObject *asyncgen_asend =
-                ((struct Nuitka_AsyncgenAsendObject *)generator->m_yieldfrom);
+                ((struct Nuitka_AsyncgenAsendObject *)generator->m_yield_from);
 
             // Transferred exception ownership to "_Nuitka_AsyncgenAsend_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
-            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_type, exception_value, exception_tb);
+            ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #endif
 #endif
         } else {
-            PyObject *meth = PyObject_GetAttr(generator->m_yieldfrom, const_str_plain_throw);
+            PyObject *meth = PyObject_GetAttr(generator->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;
                 }
@@ -1097,35 +1192,33 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
                 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_MarkGeneratorAsRunning(generator);
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 
             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 (generator->m_yieldfrom != NULL) {
-                CHECK_OBJECT(generator->m_yieldfrom);
+            if (generator->m_yield_from != NULL) {
+                CHECK_OBJECT(generator->m_yield_from);
 #if _DEBUG_GENERATOR
                 PRINT_GENERATOR_STATUS("Null return, yield from removal:", generator);
-                PRINT_COROUTINE_VALUE("yieldfrom", generator->m_yieldfrom);
+                PRINT_COROUTINE_VALUE("yield_from", generator->m_yield_from);
 #endif
-                Py_DECREF(generator->m_yieldfrom);
-                generator->m_yieldfrom = NULL;
+                Py_DECREF(generator->m_yield_from);
+                generator->m_yield_from = NULL;
             }
 
             PyObject *val;
@@ -1138,14 +1231,21 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
                 PRINT_NEW_LINE();
 #endif
 
-                ret = _Nuitka_Generator_send(tstate, generator, val, NULL, NULL, NULL);
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+                ret = _Nuitka_Generator_send(tstate, generator, val, &no_exception_state);
             } else {
 #if _DEBUG_GENERATOR
                 PRINT_GENERATOR_STATUS("Sending exception value into ourselves", generator);
                 PRINT_CURRENT_EXCEPTION();
                 PRINT_NEW_LINE();
 #endif
-                ret = _Nuitka_Generator_send(tstate, generator, NULL, NULL, NULL, NULL);
+
+                struct Nuitka_ExceptionPreservationItem no_exception_state;
+                INIT_ERROR_OCCURRED_STATE(&no_exception_state);
+
+                ret = _Nuitka_Generator_send(tstate, generator, NULL, &no_exception_state);
             }
 
 #if _DEBUG_GENERATOR
@@ -1171,15 +1271,14 @@ 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 (generator->m_status == status_Running) {
         // Passing exception ownership to _Nuitka_Generator_send
-        PyObject *result =
-            _Nuitka_Generator_send(tstate, generator, NULL, exception_type, exception_value, exception_tb);
+        PyObject *result = _Nuitka_Generator_send(tstate, generator, NULL, exception_state);
 
         if (result == NULL) {
             if (GET_ERROR_OCCURRED(tstate) == NULL) {
@@ -1189,21 +1288,24 @@ throw_here:
 
         return result;
     } else if (generator->m_status == status_Finished) {
-        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, generator->m_code_object, generator->m_module, 0);
-            exception_tb = MAKE_TRACEBACK(frame, generator->m_code_object->co_firstlineno);
+            SET_EXCEPTION_STATE_TRACEBACK(exception_state,
+                                          MAKE_TRACEBACK(frame, generator->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);
 
         Nuitka_MarkGeneratorAsFinished(generator);
 
@@ -1223,14 +1325,16 @@ static PyObject *Nuitka_Generator_throw(struct Nuitka_GeneratorObject *generator
         return NULL;
     }
 
-    // Handing ownership of exception over, we need not release it ourselves
-    Py_INCREF(exception_type);
-    Py_XINCREF(exception_value);
-    Py_XINCREF(exception_tb);
-
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *result = _Nuitka_Generator_throw2(tstate, generator, exception_type, exception_value, exception_tb);
+    // Handing ownership of exception over, we need not release it ourselves
+    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_Generator_throw2(tstate, generator, &exception_state);
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
@@ -1248,7 +1352,7 @@ static PyObject *Nuitka_Generator_throw(struct Nuitka_GeneratorObject *generator
     return result;
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static void Nuitka_Generator_tp_finalizer(struct Nuitka_GeneratorObject *generator) {
     if (generator->m_status != status_Running) {
         return;
@@ -1256,9 +1360,8 @@ static void Nuitka_Generator_tp_finalizer(struct Nuitka_GeneratorObject *generat
 
     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_Generator_close(tstate, generator);
 
@@ -1266,8 +1369,8 @@ static void Nuitka_Generator_tp_finalizer(struct Nuitka_GeneratorObject *generat
         PyErr_WriteUnraisable((PyObject *)generator);
     }
 
-    /* Restore the saved exception if any. */
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    // Restore the saved exception if any.
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 #endif
 
@@ -1276,6 +1379,11 @@ static struct Nuitka_GeneratorObject *free_list_generators = NULL;
 static int free_list_generators_count = 0;
 
 static void Nuitka_Generator_tp_dealloc(struct Nuitka_GeneratorObject *generator) {
+#if _DEBUG_REFCOUNTS
+    count_active_Nuitka_Generator_Type -= 1;
+    count_released_Nuitka_Generator_Type += 1;
+#endif
+
     // Revive temporarily.
     assert(Py_REFCNT(generator) == 0);
     Py_SET_REFCNT(generator, 1);
@@ -1283,9 +1391,8 @@ static void Nuitka_Generator_tp_dealloc(struct Nuitka_GeneratorObject *generator
     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 (generator->m_status == status_Running) {
         bool close_result = _Nuitka_Generator_close(tstate, generator);
@@ -1305,7 +1412,7 @@ static void Nuitka_Generator_tp_dealloc(struct Nuitka_GeneratorObject *generator
     }
 
     if (generator->m_frame != NULL) {
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
         Nuitka_SetFrameGenerator(generator->m_frame, NULL);
 #endif
         Py_DECREF(generator->m_frame);
@@ -1329,7 +1436,7 @@ static void Nuitka_Generator_tp_dealloc(struct Nuitka_GeneratorObject *generator
     /* Put the object into free list or release to GC */
     releaseToFreeList(free_list_generators, generator, MAX_GENERATOR_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 long Nuitka_Generator_tp_hash(struct Nuitka_GeneratorObject *generator) { return generator->m_counter; }
@@ -1382,11 +1489,11 @@ static int Nuitka_Generator_set_qualname(struct Nuitka_GeneratorObject *generato
 }
 
 static PyObject *Nuitka_Generator_get_yieldfrom(struct Nuitka_GeneratorObject *generator) {
-    if (generator->m_yieldfrom) {
-        Py_INCREF(generator->m_yieldfrom);
-        return generator->m_yieldfrom;
+    if (generator->m_yield_from) {
+        Py_INCREF(generator->m_yield_from);
+        return generator->m_yield_from;
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -1434,7 +1541,7 @@ static PyObject *Nuitka_Generator_get_running(struct Nuitka_GeneratorObject *gen
     result = PyInt_FromLong(generator->m_running);
 #else
     result = BOOL_FROM(generator->m_running != 0);
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
 #endif
     return result;
 }
@@ -1457,7 +1564,7 @@ static int Nuitka_Generator_set_running(struct Nuitka_GeneratorObject *generator
     return -1;
 }
 
-static PyGetSetDef Nuitka_Generator_getsetlist[] = {
+static PyGetSetDef Nuitka_Generator_tp_getset[] = {
 #if PYTHON_VERSION < 0x350
     {(char *)"__name__", (getter)Nuitka_Generator_get_name, NULL, NULL},
 #else
@@ -1487,8 +1594,6 @@ static PyAsyncMethods Nuitka_Generator_as_async = {
 };
 #endif
 
-#include <structmember.h>
-
 PyTypeObject Nuitka_Generator_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "compiled_generator", // tp_name
     sizeof(struct Nuitka_GeneratorObject),               // tp_basicsize
@@ -1527,7 +1632,7 @@ PyTypeObject Nuitka_Generator_Type = {
     (iternextfunc)Nuitka_Generator_tp_iternext,          // tp_iternext
     Nuitka_Generator_methods,                            // tp_methods
     NULL,                                                // tp_members
-    Nuitka_Generator_getsetlist,                         // tp_getset
+    Nuitka_Generator_tp_getset,                          // tp_getset
     0,                                                   // tp_base
     0,                                                   // tp_dict
     0,                                                   // tp_descr_get
@@ -1545,7 +1650,7 @@ PyTypeObject Nuitka_Generator_Type = {
     0,                                                   // tp_weaklist
     0,                                                   // tp_del
     0                                                    // tp_version_tag
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     ,
     (destructor)Nuitka_Generator_tp_finalizer // tp_finalize
 #endif
@@ -1591,7 +1696,7 @@ void _initCompiledGeneratorType(void) {
     assert(Nuitka_Generator_Type.tp_subclasses != PyGen_Type.tp_subclasses || PyGen_Type.tp_cache == NULL);
     assert(Nuitka_Generator_Type.tp_weaklist != PyGen_Type.tp_weaklist);
     assert(Nuitka_Generator_Type.tp_del != PyGen_Type.tp_del || PyGen_Type.tp_del == NULL);
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     assert(Nuitka_Generator_Type.tp_finalize != PyGen_Type.tp_finalize || PyGen_Type.tp_finalize == NULL);
 #endif
 
@@ -1612,6 +1717,11 @@ PyObject *Nuitka_Generator_New(generator_code code, PyObject *module, PyObject *
 #endif
                                PyCodeObject *code_object, struct Nuitka_CellObject **closure, Py_ssize_t closure_given,
                                Py_ssize_t heap_storage_size) {
+#if _DEBUG_REFCOUNTS
+    count_active_Nuitka_Generator_Type += 1;
+    count_allocated_Nuitka_Generator_Type += 1;
+#endif
+
     struct Nuitka_GeneratorObject *result;
 
     // TODO: Change the var part of the type to 1 maybe
@@ -1649,7 +1759,7 @@ PyObject *Nuitka_Generator_New(generator_code code, PyObject *module, PyObject *
 #endif
 
 #if PYTHON_VERSION >= 0x300
-    result->m_yieldfrom = NULL;
+    result->m_yield_from = NULL;
 #endif
 
     memcpy(&result->m_closure[0], closure, closure_given * sizeof(struct Nuitka_CellObject *));
@@ -1707,4 +1817,18 @@ PyObject *Nuitka_Generator_NewEmpty(PyObject *module, PyObject *name,
 
 // Chain frames to generator and asyncgen code, as they need to close them with access
 // to best functions.
-#include "CompiledFrameType.c"
+#include "CompiledFrameType.c"
+//     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.