Nuitka-winsvc 2.5.6__cp311-cp311-win_amd64.whl → 2.6__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled Asyncgen.
  *
@@ -177,13 +177,13 @@ static int Nuitka_Asyncgen_set_frame(PyObject *self, PyObject *value, void *data
 }
 
 static void Nuitka_Asyncgen_release_closure(struct Nuitka_AsyncgenObject *asyncgen) {
-    CHECK_OBJECT(asyncgen);
-
     for (Py_ssize_t i = 0; i < asyncgen->m_closure_given; i++) {
         CHECK_OBJECT(asyncgen->m_closure[i]);
         Py_DECREF(asyncgen->m_closure[i]);
     }
 
+    // This can be ran multiple times, set the count to zero,
+    // after first run, which deactivates the above loop.
     asyncgen->m_closure_given = 0;
 }
 
@@ -367,6 +367,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
         PyObject *yielded;
 
         if (asyncgen->m_yield_from == NULL) {
+            // This consumes a reference to the value.
             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.
@@ -397,7 +398,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
         _Nuitka_GeneratorPopFrame(tstate, return_frame);
 
 #if _DEBUG_ASYNCGEN
-        PRINT_ASYNCGEN_STATUS("Returned from coroutine", asyncgen);
+        PRINT_ASYNCGEN_STATUS("Returned from asyncgen", asyncgen);
         // dumpFrameStack();
 #endif
 
@@ -792,7 +793,7 @@ static PyObject *Nuitka_Asyncgen_throw(PyThreadState *tstate, struct Nuitka_Asyn
     return result;
 }
 
-static int _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen) {
+static bool _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen) {
     /* Just do this once per async generator object. */
     if (asyncgen->m_hooks_init_done) {
         return 0;
@@ -816,13 +817,13 @@ static int _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_Asyn
         Py_DECREF(firstiter);
 
         if (unlikely(res == NULL)) {
-            return 1;
+            return true;
         }
 
         Py_DECREF(res);
     }
 
-    return 0;
+    return false;
 }
 
 static PyObject *Nuitka_AsyncgenAsend_New(struct Nuitka_AsyncgenObject *asyncgen, PyObject *sendval);
@@ -896,13 +897,13 @@ static PySendResult _Nuitka_Asyncgen_am_send(struct Nuitka_AsyncgenObject *async
 #endif
 
     *result = NULL;
-    Py_INCREF(arg);
 
     PyThreadState *tstate = PyThreadState_GET();
 
     struct Nuitka_ExceptionPreservationItem exception_state;
     INIT_ERROR_OCCURRED_STATE(&exception_state);
 
+    Py_INCREF(arg);
     PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, arg, false, &exception_state, result);
 
 #if _DEBUG_ASYNCGEN
@@ -922,6 +923,26 @@ static void Nuitka_Asyncgen_tp_finalize(struct Nuitka_AsyncgenObject *asyncgen)
     PyThreadState *tstate = PyThreadState_GET();
 
     struct Nuitka_ExceptionPreservationItem saved_exception_state;
+
+    // Need to call registered finalizer if provided, "asyncio" seems to do
+    // that.
+    PyObject *finalizer = asyncgen->m_finalizer;
+    if (finalizer != NULL && asyncgen->m_closed == false) {
+        // 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);
+
+        if (unlikely(res == NULL)) {
+            PyErr_WriteUnraisable((PyObject *)asyncgen);
+        } else {
+            Py_DECREF(res);
+        }
+
+        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+        return;
+    }
+
     FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     bool close_result = _Nuitka_Asyncgen_close(tstate, asyncgen);
@@ -944,69 +965,56 @@ static void Nuitka_Asyncgen_tp_dealloc(struct Nuitka_AsyncgenObject *asyncgen) {
     count_active_Nuitka_Asyncgen_Type -= 1;
     count_released_Nuitka_Asyncgen_Type += 1;
 #endif
+    if (asyncgen->m_weakrefs != NULL) {
+        Nuitka_GC_UnTrack(asyncgen);
 
-    // Revive temporarily.
-    assert(Py_REFCNT(asyncgen) == 0);
-    Py_SET_REFCNT(asyncgen, 1);
+        // TODO: Avoid API call and make this our own function to reuse the
+        // pattern of temporarily untracking the value or maybe even to avoid
+        // the need to do it. It may also be a lot of work to do that though
+        // and maybe having weakrefs is uncommon.
+        PyObject_ClearWeakRefs((PyObject *)asyncgen);
+        assert(!HAS_ERROR_OCCURRED(PyThreadState_GET()));
 
-    PyThreadState *tstate = PyThreadState_GET();
+        Nuitka_GC_Track(asyncgen);
+    }
 
-    // Save the current exception, if any, we must preserve it.
-    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    // TODO: Avoid this API call, it's bound to be slow on some platforms and
+    // does more checks than necessary for us.
+    if (PyObject_CallFinalizerFromDealloc((PyObject *)asyncgen)) {
+        return;
+    }
+    // if (!_PyGC_FINALIZED(asyncgen)) {
+    //     Nuitka_Asyncgen_tp_finalize(asyncgen);
 
-    PyObject *finalizer = asyncgen->m_finalizer;
-    if (finalizer != NULL && asyncgen->m_closed == false) {
-        // Save the current exception, if any.
-        FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+    //     _PyGC_SET_FINALIZED(asyncgen);
+    // }
 
-        PyObject *res = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, finalizer, (PyObject *)asyncgen);
+    Nuitka_GC_UnTrack(asyncgen);
 
-        if (unlikely(res == NULL)) {
-            PyErr_WriteUnraisable((PyObject *)asyncgen);
-        } else {
-            Py_DECREF(res);
-        }
+    PyThreadState *tstate = PyThreadState_GET();
 
-        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
-        return;
-    }
+    // Save the current exception, if any, we must preserve it.
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
     FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
-    bool close_result = _Nuitka_Asyncgen_close(tstate, asyncgen);
-
-    if (unlikely(close_result == false)) {
-        PyErr_WriteUnraisable((PyObject *)asyncgen);
-    }
-
     Nuitka_Asyncgen_release_closure(asyncgen);
 
-    // Allow for above code to resurrect the coroutine, do not release the object
-    // like Py_DECREF would.
-    Py_SET_REFCNT(asyncgen, Py_REFCNT(asyncgen) - 1);
-    if (Py_REFCNT(asyncgen) >= 1) {
-        return;
-    }
+    Py_XDECREF(asyncgen->m_finalizer);
 
     if (asyncgen->m_frame) {
         Nuitka_SetFrameGenerator(asyncgen->m_frame, NULL);
         Py_DECREF(asyncgen->m_frame);
-        asyncgen->m_frame = NULL;
     }
 
     // Now it is safe to release references and memory for it.
-    Nuitka_GC_UnTrack(asyncgen);
-
-    Py_XDECREF(asyncgen->m_finalizer);
-
-    if (asyncgen->m_weakrefs != NULL) {
-        PyObject_ClearWeakRefs((PyObject *)asyncgen);
-        assert(!HAS_ERROR_OCCURRED(tstate));
-    }
-
     Py_DECREF(asyncgen->m_name);
     Py_DECREF(asyncgen->m_qualname);
 
+    // TODO: Maybe push this into the freelist code and do
+    // it on allocation.
+    _PyGC_SET_UNFINALIZED((PyObject *)asyncgen);
+
     /* Put the object into free list or release to GC */
     releaseToFreeList(free_list_asyncgens, asyncgen, MAX_ASYNCGEN_FREE_LIST_COUNT);
 
@@ -1310,8 +1318,8 @@ struct Nuitka_AsyncgenAsendObject {
 
 #if _DEBUG_ASYNCGEN
 
-NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENASEND_STATUS(char const *descriptor, char const *context,
-                                                             struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
+NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGEN_ASEND_STATUS(char const *descriptor, char const *context,
+                                                              struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
     char const *status;
 
     switch (asyncgen_asend->m_state) {
@@ -1339,8 +1347,8 @@ NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENASEND_STATUS(char const *descrip
     PRINT_NEW_LINE();
 }
 
-#define PRINT_ASYNCGENASEND_STATUS(context, asyncgen_asend)                                                            \
-    _PRINT_ASYNCGENASEND_STATUS(__FUNCTION__, context, asyncgen_asend)
+#define PRINT_ASYNCGEN_ASEND_STATUS(context, asyncgen_asend)                                                           \
+    _PRINT_ASYNCGEN_ASEND_STATUS(__FUNCTION__, context, asyncgen_asend)
 
 #endif
 
@@ -1447,7 +1455,7 @@ static int Nuitka_AsyncgenAsend_tp_traverse(struct Nuitka_AsyncgenAsendObject *a
 
 static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *arg) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_COROUTINE_VALUE("arg", arg);
     PRINT_NEW_LINE();
 #endif
@@ -1462,7 +1470,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 #endif
 
 #if _DEBUG_ASYNCGEN
-        PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+        PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
         PRINT_STRING("Closed -> StopIteration\n");
         PRINT_CURRENT_EXCEPTION();
         PRINT_NEW_LINE();
@@ -1507,12 +1515,17 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
     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");
+    PRINT_ASYNCGEN_ASEND_STATUS("Returned from _Nuitka_Asyncgen_send", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
 #endif
 
     result = _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen_asend->m_gen, result);
+#if _DEBUG_ASYNCGEN
+    PRINT_ASYNCGEN_ASEND_STATUS("Returned from _Nuitka_Asyncgen_unwrap_value", asyncgen_asend);
+    PRINT_COROUTINE_VALUE("result", result);
+    PRINT_CURRENT_EXCEPTION();
+#endif
 
 #if _DEBUG_ASYNCGEN
     PRINT_COROUTINE_VALUE("result", result);
@@ -1525,7 +1538,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_NEW_LINE();
 #endif
@@ -1535,7 +1548,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 
 static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_STRING("Deferring to Nuitka_AsyncgenAsend_send(Py_None)\n");
     PRINT_NEW_LINE();
 #endif
@@ -1543,7 +1556,7 @@ static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObj
     PyObject *result = Nuitka_AsyncgenAsend_send(asyncgen_asend, Py_None);
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_NEW_LINE();
 #endif
@@ -1553,7 +1566,7 @@ static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObj
 
 static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *args) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_STRING("Nuitka_AsyncgenAsend_throw: args:");
     PRINT_ITEM(args);
     PRINT_NEW_LINE();
@@ -1601,7 +1614,7 @@ static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *a
 static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuitka_AsyncgenAsendObject *asyncgen_asend,
                                               struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_EXCEPTION_STATE(exception_state);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
@@ -1623,7 +1636,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Got result", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Got result", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
 #endif
@@ -1640,7 +1653,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
@@ -1753,8 +1766,8 @@ struct Nuitka_AsyncgenAthrowObject {
 
 #if _DEBUG_ASYNCGEN
 
-NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENATHROW_STATUS(char const *descriptor, char const *context,
-                                                              struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
+NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGEN_ATHROW_STATUS(char const *descriptor, char const *context,
+                                                               struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
     char const *status;
 
     switch (asyncgen_athrow->m_state) {
@@ -1782,8 +1795,8 @@ NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENATHROW_STATUS(char const *descri
     PRINT_NEW_LINE();
 }
 
-#define PRINT_ASYNCGENATHROW_STATUS(context, coroutine)                                                                \
-    _PRINT_ASYNCGENATHROW_STATUS(__FUNCTION__, context, asyncgen_athrow)
+#define PRINT_ASYNCGEN_ATHROW_STATUS(context, coroutine)                                                               \
+    _PRINT_ASYNCGEN_ATHROW_STATUS(__FUNCTION__, context, asyncgen_athrow)
 
 #endif
 
@@ -1818,7 +1831,7 @@ static int Nuitka_AsyncgenAthrow_traverse(struct Nuitka_AsyncgenAthrowObject *as
 
 static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow, PyObject *arg) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENATHROW_STATUS("Enter", asyncgen_athrow);
+    PRINT_ASYNCGEN_ATHROW_STATUS("Enter", asyncgen_athrow);
     PRINT_COROUTINE_VALUE("arg", arg);
     PRINT_NEW_LINE();
 #endif
@@ -1893,7 +1906,7 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
                                              1, /* Do not close generator when PyExc_GeneratorExit is passed */
                                              &exception_state);
 
-            if (retval) {
+            if (retval != NULL) {
                 if (_PyAsyncGenWrappedValue_CheckExact(retval) || Nuitka_AsyncgenWrappedValue_CheckExact(retval)) {
 #if PYTHON_VERSION >= 0x380
                     asyncgen_athrow->m_gen->m_running_async = false;
@@ -1943,13 +1956,14 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
     struct Nuitka_ExceptionPreservationItem exception_state;
     INIT_ERROR_OCCURRED_STATE(&exception_state);
 
+    Py_INCREF(arg);
     retval = _Nuitka_Asyncgen_send(tstate, asyncgen, arg, false, &exception_state);
 
     if (asyncgen_athrow->m_args) {
         return _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen, retval);
     } else {
         /* We are here to close if no args. */
-        if (retval) {
+        if (retval != NULL) {
             if (_PyAsyncGenWrappedValue_CheckExact(retval) || Nuitka_AsyncgenWrappedValue_CheckExact(retval)) {
 #if PYTHON_VERSION >= 0x380
                 asyncgen_athrow->m_gen->m_running_async = false;
@@ -1994,7 +2008,7 @@ check_error:
 
 static PyObject *Nuitka_AsyncgenAthrow_throw(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow, PyObject *args) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENATHROW_STATUS("Enter", asyncgen_athrow);
+    PRINT_ASYNCGEN_ATHROW_STATUS("Enter", asyncgen_athrow);
     PRINT_COROUTINE_VALUE("args", args);
     PRINT_NEW_LINE();
 #endif

nuitka/build/static_src/CompiledCellType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled cells.
  *
@@ -22,6 +22,7 @@ int count_allocated_Nuitka_Cell_Type;
 int count_released_Nuitka_Cell_Type;
 #endif
 
+// Freelist setup
 #define MAX_CELL_FREE_LIST_COUNT 1000
 static struct Nuitka_CellObject *free_list_cells = NULL;
 static int free_list_cells_count = 0;

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /* Implementations of compiled code helpers.
 
@@ -1595,25 +1595,6 @@ PyObject *JOIN_PATH2(PyObject *dirname, PyObject *filename) {
     return result;
 }
 
-#if defined(_WIN32)
-// Replacement for RemoveFileSpecW, slightly smaller, avoids a link library.
-NUITKA_MAY_BE_UNUSED static void stripFilenameW(wchar_t *path) {
-    wchar_t *last_slash = NULL;
-
-    while (*path != 0) {
-        if (*path == L'\\') {
-            last_slash = path;
-        }
-
-        path++;
-    }
-
-    if (last_slash != NULL) {
-        *last_slash = 0;
-    }
-}
-#endif
-
 #if defined(_NUITKA_EXE)
 
 wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
@@ -1940,13 +1921,12 @@ PyObject *getDllFilenameObject(void) {
 PyObject *getContainingDirectoryObject(bool resolve_symlinks) {
 #if defined(_NUITKA_EXE)
 #if defined(_NUITKA_ONEFILE_MODE)
-    environment_char_t const *onefile_binary = getEnvironmentVariable("NUITKA_ONEFILE_BINARY");
-    if (onefile_binary != NULL) {
-        PyObject *result = Nuitka_String_FromFilename(onefile_binary);
-        unsetEnvironmentVariable("NUITKA_ONEFILE_BINARY");
+    environment_char_t const *onefile_directory = getEnvironmentVariable("NUITKA_ONEFILE_DIRECTORY");
+    if (onefile_directory != NULL) {
+        PyObject *result = Nuitka_String_FromFilename(onefile_directory);
+        unsetEnvironmentVariable("NUITKA_ONEFILE_DIRECTORY");
 
-        PyThreadState *tstate = PyThreadState_GET();
-        return OS_PATH_DIRNAME(tstate, result);
+        return result;
     }
 
     return getBinaryDirectoryObject(resolve_symlinks);

nuitka/build/static_src/CompiledCoroutineType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled Coroutines.
  *
@@ -177,8 +177,6 @@ static int Nuitka_Coroutine_set_frame(PyObject *self, PyObject *value, void *dat
 }
 
 static void Nuitka_Coroutine_release_closure(struct Nuitka_CoroutineObject *coroutine) {
-    CHECK_OBJECT(coroutine);
-
     for (Py_ssize_t i = 0; i < coroutine->m_closure_given; i++) {
         CHECK_OBJECT(coroutine->m_closure[i]);
         Py_DECREF(coroutine->m_closure[i]);
@@ -1084,19 +1082,37 @@ static void Nuitka_Coroutine_tp_finalize(struct Nuitka_CoroutineObject *coroutin
     RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
+// Freelist setup
 #define MAX_COROUTINE_FREE_LIST_COUNT 100
-static struct Nuitka_CoroutineObject *free_list_coros = NULL;
-static int free_list_coros_count = 0;
+static struct Nuitka_CoroutineObject *free_list_coroutines = NULL;
+static int free_list_coroutines_count = 0;
 
 static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine) {
 #if _DEBUG_REFCOUNTS
     count_active_Nuitka_Coroutine_Type -= 1;
     count_released_Nuitka_Coroutine_Type += 1;
 #endif
+    if (coroutine->m_weakrefs != NULL) {
+        Nuitka_GC_UnTrack(coroutine);
+
+        // TODO: Avoid API call and make this our own function to reuse the
+        // pattern of temporarily untracking the value or maybe even to avoid
+        // the need to do it. It may also be a lot of work to do that though
+        // and maybe having weakrefs is uncommon.
+        PyObject_ClearWeakRefs((PyObject *)coroutine);
+        assert(!HAS_ERROR_OCCURRED(PyThreadState_GET()));
 
-    // Revive temporarily.
-    assert(Py_REFCNT(coroutine) == 0);
-    Py_SET_REFCNT(coroutine, 1);
+        Nuitka_GC_Track(coroutine);
+    }
+
+    // TODO: Avoid this API call, it's bound to be slow on some platforms and
+    // does more checks than necessary for us.
+    if (PyObject_CallFinalizerFromDealloc((PyObject *)coroutine)) {
+        return;
+    }
+
+    // Now it is safe to release references and memory for it.
+    Nuitka_GC_UnTrack(coroutine);
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -1109,44 +1125,26 @@ static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine
     PRINT_NEW_LINE();
 #endif
 
-    bool close_result = _Nuitka_Coroutine_close(tstate, coroutine);
-
-    if (unlikely(close_result == false)) {
-        PyErr_WriteUnraisable((PyObject *)coroutine);
-    }
-
     Nuitka_Coroutine_release_closure(coroutine);
 
-    // Allow for above code to resurrect the coroutine.
-    Py_SET_REFCNT(coroutine, Py_REFCNT(coroutine) - 1);
-    if (Py_REFCNT(coroutine) >= 1) {
-        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
-        return;
-    }
-
     if (coroutine->m_frame) {
         Nuitka_SetFrameGenerator(coroutine->m_frame, NULL);
         Py_DECREF(coroutine->m_frame);
-        coroutine->m_frame = NULL;
     }
 
-    // Now it is safe to release references and memory for it.
-    Nuitka_GC_UnTrack(coroutine);
-
-    if (coroutine->m_weakrefs != NULL) {
-        PyObject_ClearWeakRefs((PyObject *)coroutine);
-        assert(!HAS_ERROR_OCCURRED(tstate));
-    }
+#if PYTHON_VERSION >= 0x370
+    Py_XDECREF(coroutine->m_origin);
+#endif
 
     Py_DECREF(coroutine->m_name);
     Py_DECREF(coroutine->m_qualname);
 
-#if PYTHON_VERSION >= 0x370
-    Py_XDECREF(coroutine->m_origin);
-#endif
+    // TODO: Maybe push this into the freelist code and do
+    // it on allocation.
+    _PyGC_SET_UNFINALIZED((PyObject *)coroutine);
 
     /* Put the object into free list or release to GC */
-    releaseToFreeList(free_list_coros, coroutine, MAX_COROUTINE_FREE_LIST_COUNT);
+    releaseToFreeList(free_list_coroutines, coroutine, MAX_COROUTINE_FREE_LIST_COUNT);
 
     RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
@@ -1435,7 +1433,7 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     Py_ssize_t full_size = closure_given + (heap_storage_size + sizeof(void *) - 1) / sizeof(void *);
 
     // Macro to assign result memory from GC or free list.
-    allocateFromFreeList(free_list_coros, struct Nuitka_CoroutineObject, Nuitka_Coroutine_Type, full_size);
+    allocateFromFreeList(free_list_coroutines, struct Nuitka_CoroutineObject, Nuitka_Coroutine_Type, full_size);
 
     // For quicker access of generator heap.
     result->m_heap_storage = &result->m_closure[closure_given];

nuitka/build/static_src/CompiledFrameType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 #ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
@@ -268,11 +268,20 @@ static int _Nuitka_Frame_set_trace(PyObject *self, PyObject *value, void *data)
     assert(Nuitka_Frame_CheckExact(self));
     CHECK_OBJECT(self);
     assert(_PyObject_GC_IS_TRACKED(self));
+#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_FRAME_USELESS_SET_TRACE)
+    if (value == Py_None) {
+        return 0;
+    } else {
+        PyThreadState *tstate = PyThreadState_GET();
 
-    PyThreadState *tstate = PyThreadState_GET();
-
-    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace is not writable in Nuitka");
-    return -1;
+        SET_CURRENT_EXCEPTION_TYPE0_STR(
+            tstate, PyExc_RuntimeError,
+            "f_trace is not writable in Nuitka, ignore with '--no-deployment-flag=frame-useless-set-trace'");
+        return -1;
+    }
+#else
+    return 0;
+#endif
 }
 
 #if PYTHON_VERSION >= 0x370
@@ -404,6 +413,7 @@ static void Nuitka_Frame_tp_clear(struct Nuitka_FrameObject *frame) {
     }
 }
 
+// Freelist setup
 #define MAX_FRAME_FREE_LIST_COUNT 100
 static struct Nuitka_FrameObject *free_list_frames = NULL;
 static int free_list_frames_count = 0;
@@ -543,6 +553,14 @@ static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc
 
 #if PYTHON_VERSION >= 0x300
 
+static PyObject *Nuitka_GetFrameGenerator(struct Nuitka_FrameObject *nuitka_frame) {
+#if PYTHON_VERSION < 0x3b0
+    return nuitka_frame->m_frame.f_gen;
+#else
+    return nuitka_frame->m_generator;
+#endif
+}
+
 static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame, PyObject *unused) {
     assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
@@ -875,8 +893,17 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
                              int pos_only_count
 #endif
 ) {
+
+    if (filename == Py_None) {
+        filename = const_str_empty;
+    }
+
+    // TODO: We don't do that anymore once new-code-objects
+    // is the default, then we don't need to pass it, since
+    // we create them incomplete anyway.
     CHECK_OBJECT(filename);
     assert(Nuitka_StringOrUnicode_CheckExact(filename));
+
     CHECK_OBJECT(function_name);
     assert(Nuitka_String_CheckExact(function_name));
 
@@ -1034,9 +1061,40 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
     Py_DECREF(filename_str);
 #endif
 
+    if (result == NULL) {
+        PyErr_PrintEx(0);
+        NUITKA_CANNOT_GET_HERE("Failed to create code object");
+    }
+
     return result;
 }
 
+PyCodeObject *USE_CODE_OBJECT(PyThreadState *tstate, PyObject *code_object, PyObject *module_filename_obj) {
+    assert(PyCode_Check(code_object));
+    CHECK_OBJECT(module_filename_obj);
+
+    PyCodeObject *co = (PyCodeObject *)code_object;
+    PyObject *old = co->co_filename;
+
+    if (old == const_str_empty) {
+        // Set the filename, ignore the loss of a reference to empty string,
+        // that's our singleton and immortal at least practically.
+        co->co_filename = Py_NewRef(module_filename_obj);
+
+#if PYTHON_VERSION >= 0x3b0
+        // Also, make sure the qualname is completed from the partial
+        // name.
+        if (co->co_qualname != co->co_name) {
+            PyObject *w = UNICODE_CONCAT(tstate, co->co_qualname, const_str_dot);
+            co->co_qualname = UNICODE_CONCAT(tstate, w, co->co_name);
+            Py_DECREF(w);
+        }
+#endif
+    }
+
+    return co;
+}
+
 void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char const *type_description, ...) {
     assert(Nuitka_Frame_CheckExact((PyObject *)frame_object));
     CHECK_OBJECT((PyObject *)frame_object);