Nuitka-winsvc 2.2.2__cp311-cp311-win_amd64.whl → 2.3__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledFrameType.c

@@ -37,7 +37,7 @@ static PyMemberDef Nuitka_Frame_memberlist[] = {
 #if PYTHON_VERSION < 0x300
 
 static PyObject *Nuitka_Frame_get_exc_traceback(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -52,7 +52,7 @@ static PyObject *Nuitka_Frame_get_exc_traceback(struct Nuitka_FrameObject *frame
 }
 
 static int Nuitka_Frame_set_exc_traceback(struct Nuitka_FrameObject *frame, PyObject *traceback) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -69,7 +69,7 @@ static int Nuitka_Frame_set_exc_traceback(struct Nuitka_FrameObject *frame, PyOb
 }
 
 static PyObject *Nuitka_Frame_get_exc_type(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -86,7 +86,7 @@ static PyObject *Nuitka_Frame_get_exc_type(struct Nuitka_FrameObject *frame) {
 }
 
 static int Nuitka_Frame_set_exc_type(struct Nuitka_FrameObject *frame, PyObject *exception_type) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -105,7 +105,7 @@ static int Nuitka_Frame_set_exc_type(struct Nuitka_FrameObject *frame, PyObject
 }
 
 static PyObject *Nuitka_Frame_get_exc_value(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -122,7 +122,7 @@ static PyObject *Nuitka_Frame_get_exc_value(struct Nuitka_FrameObject *frame) {
 }
 
 static int Nuitka_Frame_set_exc_value(struct Nuitka_FrameObject *frame, PyObject *exception_value) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -140,21 +140,23 @@ static int Nuitka_Frame_set_exc_value(struct Nuitka_FrameObject *frame, PyObject
 }
 
 static PyObject *Nuitka_Frame_get_restricted(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
-    Py_INCREF(Py_False);
+    Py_INCREF_IMMORTAL(Py_False);
     return Py_False;
 }
 
 #endif
 
 static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)nuitka_frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)nuitka_frame));
     CHECK_OBJECT((PyObject *)nuitka_frame);
     assert(_PyObject_GC_IS_TRACKED(nuitka_frame));
 
+    NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
     if (nuitka_frame->m_type_description == NULL) {
 #if PYTHON_VERSION < 0x3b0
         PyFrameObject *locals_owner = &nuitka_frame->m_frame;
@@ -163,13 +165,13 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
 #endif
 
         if (locals_owner->f_locals == NULL) {
-            locals_owner->f_locals = MAKE_DICT_EMPTY();
+            locals_owner->f_locals = MAKE_DICT_EMPTY(tstate);
         }
 
         Py_INCREF(locals_owner->f_locals);
         return locals_owner->f_locals;
     } else {
-        PyObject *result = MAKE_DICT_EMPTY();
+        PyObject *result = MAKE_DICT_EMPTY(tstate);
         PyObject **var_names = Nuitka_GetCodeVarNames(Nuitka_GetFrameCodeObject(nuitka_frame));
 
         char const *w = nuitka_frame->m_type_description;
@@ -236,7 +238,7 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
 }
 
 static PyObject *Nuitka_Frame_getlineno(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -244,7 +246,7 @@ static PyObject *Nuitka_Frame_getlineno(struct Nuitka_FrameObject *frame, void *
 }
 
 static PyObject *Nuitka_Frame_gettrace(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -254,7 +256,7 @@ static PyObject *Nuitka_Frame_gettrace(struct Nuitka_FrameObject *frame, void *c
 }
 
 static int Nuitka_Frame_settrace(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -266,17 +268,17 @@ static int Nuitka_Frame_settrace(struct Nuitka_FrameObject *frame, PyObject *v,
 
 #if PYTHON_VERSION >= 0x370
 static PyObject *Nuitka_Frame_gettracelines(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
     PyObject *result = Py_False;
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
 static int Nuitka_Frame_settracelines(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -287,17 +289,17 @@ static int Nuitka_Frame_settracelines(struct Nuitka_FrameObject *frame, PyObject
 }
 
 static PyObject *Nuitka_Frame_gettraceopcodes(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
     PyObject *result = Py_False;
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
 static int Nuitka_Frame_settraceopcodes(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -310,7 +312,7 @@ static int Nuitka_Frame_settraceopcodes(struct Nuitka_FrameObject *frame, PyObje
 
 #if PYTHON_VERSION >= 0x3b0
 static PyObject *Nuitka_Frame_getback(struct Nuitka_FrameObject *frame, void *closure) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -339,7 +341,7 @@ static PyGetSetDef Nuitka_Frame_getsetlist[] = {
 
 // tp_repr slot, decide how a function shall be output
 static PyObject *Nuitka_Frame_tp_repr(struct Nuitka_FrameObject *nuitka_frame) {
-    assert(Nuitka_Frame_Check((PyObject *)nuitka_frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)nuitka_frame));
     CHECK_OBJECT((PyObject *)nuitka_frame);
     assert(_PyObject_GC_IS_TRACKED(nuitka_frame));
 
@@ -433,6 +435,7 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
     _PyInterpreterFrame *locals_owner = &nuitka_frame->m_interpreter_frame;
 #endif
 
+    assert(Nuitka_GC_IS_TRACKED_X((PyObject *)frame->f_back));
     Py_XDECREF(frame->f_back);
     Py_DECREF(locals_owner->f_builtins);
     Py_DECREF(locals_owner->f_globals);
@@ -471,7 +474,7 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
 }
 
 static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc visit, void *arg) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -541,7 +544,7 @@ static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc
 #if PYTHON_VERSION >= 0x340
 
 static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -623,7 +626,7 @@ static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame) {
 #endif
 
 static inline Py_ssize_t Nuitka_Frame_GetSize(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -635,7 +638,7 @@ static inline Py_ssize_t Nuitka_Frame_GetSize(struct Nuitka_FrameObject *frame)
 }
 
 static PyObject *Nuitka_Frame_sizeof(struct Nuitka_FrameObject *frame) {
-    assert(Nuitka_Frame_Check((PyObject *)frame));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
     CHECK_OBJECT((PyObject *)frame);
     assert(_PyObject_GC_IS_TRACKED(frame));
 
@@ -751,7 +754,12 @@ static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObj
     _PyInterpreterFrame *locals_owner = &result->m_interpreter_frame;
 #endif
 
+#if PYTHON_VERSION < 0x3d0
     locals_owner->f_code = code;
+#else
+    // TODO: Why is our code object not just immortal.
+    locals_owner->f_executable = (PyObject *)code;
+#endif
 
     frame->f_trace = Py_None;
 
@@ -798,9 +806,16 @@ static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObj
 
 #if PYTHON_VERSION >= 0x3b0
     result->m_interpreter_frame.frame_obj = &result->m_frame;
-    result->m_interpreter_frame.owner = 0;
+    result->m_interpreter_frame.owner = FRAME_OWNED_BY_GENERATOR;
+#if PYTHON_VERSION >= 0x3c0
+    result->m_interpreter_frame.f_funcobj = NULL;
+#else
+    result->m_interpreter_frame.f_func = NULL;
     result->m_interpreter_frame.prev_instr = _PyCode_CODE(code);
+#endif
     result->m_frame.f_frame = &result->m_interpreter_frame;
+
+    assert(!_PyFrame_IsIncomplete(&result->m_interpreter_frame));
 #endif
 
     Nuitka_GC_Track(result);
@@ -980,7 +995,7 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
 }
 
 void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char const *type_description, ...) {
-    assert(Nuitka_Frame_Check((PyObject *)frame_object));
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame_object));
     CHECK_OBJECT((PyObject *)frame_object);
     assert(_PyObject_GC_IS_TRACKED(frame_object));
     assertFrameObject(frame_object);
@@ -1078,9 +1093,6 @@ void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char con
 void dumpFrameStack(void) {
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *saved_exception_type, *saved_exception_value;
-    PyTracebackObject *saved_exception_tb;
-
     struct Nuitka_ExceptionPreservationItem saved_exception_state;
     FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
@@ -1118,7 +1130,7 @@ void dumpFrameStack(void) {
             current_repr = const_str_empty;
             Py_INCREF(const_str_empty);
         }
-        PyObject *code_repr = PyObject_Str((PyObject *)current->current_frame->f_code);
+        PyObject *code_repr = PyObject_Str((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(current->current_frame));
 #endif
 
         PRINT_FORMAT("Frame stack %d: %s %d %s\n", total--, Nuitka_String_AsString(current_repr), Py_REFCNT(current),
@@ -1174,7 +1186,7 @@ void PRINT_INTERPRETER_FRAME(char const *prefix, Nuitka_ThreadStateFrameType *fr
     if (frame) {
         PRINT_FORMAT("0x%lx ", frame);
 
-        PyObject *code_object_str = PyObject_Repr((PyObject *)frame->f_code);
+        PyObject *code_object_str = PyObject_Repr((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(frame));
         PRINT_ITEM(code_object_str);
         Py_DECREF(code_object_str);
     } else {
@@ -1191,7 +1203,7 @@ void PRINT_TOP_FRAME(char const *prefix) {
 #if PYTHON_VERSION < 0x3b0
     PRINT_UNCOMPILED_FRAME(prefix, tstate->frame);
 #else
-    PRINT_INTERPRETER_FRAME(prefix, tstate->cframe->current_frame);
+    PRINT_INTERPRETER_FRAME(prefix, CURRENT_TSTATE_INTERPRETER_FRAME(tstate));
 #endif
 }
 

nuitka/build/static_src/CompiledFunctionType.c

@@ -45,13 +45,11 @@ static PyObject *Nuitka_Function_tp_repr(struct Nuitka_FunctionObject *function)
     assert(Nuitka_Function_Check((PyObject *)function));
     assert(_PyObject_GC_IS_TRACKED(function));
 
-    return Nuitka_String_FromFormat("<compiled_function %s at %p>",
 #if PYTHON_VERSION < 0x300
-                                    Nuitka_String_AsString(function->m_name),
+    return Nuitka_String_FromFormat("<compiled_function %s at %p>", Nuitka_String_AsString(function->m_name), function);
 #else
-                                    Nuitka_String_AsString(function->m_qualname),
+    return Nuitka_String_FromFormat("<compiled_function %U at %p>", function->m_qualname, function);
 #endif
-                                    function);
 }
 
 static long Nuitka_Function_tp_traverse(struct Nuitka_FunctionObject *function, visitproc visit, void *arg) {
@@ -192,7 +190,9 @@ static PyObject *Nuitka_Function_get_dict(struct Nuitka_FunctionObject *function
     assert(_PyObject_GC_IS_TRACKED(function));
 
     if (function->m_dict == NULL) {
-        function->m_dict = MAKE_DICT_EMPTY();
+        NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
+        function->m_dict = MAKE_DICT_EMPTY(tstate);
     }
 
     CHECK_OBJECT(function->m_dict);
@@ -309,9 +309,10 @@ static PyObject *Nuitka_Function_get_closure(struct Nuitka_FunctionObject *funct
     assert(_PyObject_GC_IS_TRACKED(function));
 
     if (function->m_closure_given > 0) {
-        return MAKE_TUPLE((PyObject *const *)function->m_closure, function->m_closure_given);
+        NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+        return MAKE_TUPLE(tstate, (PyObject *const *)function->m_closure, function->m_closure_given);
     } else {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 }
@@ -440,7 +441,9 @@ static PyObject *Nuitka_Function_get_annotations(struct Nuitka_FunctionObject *f
     assert(_PyObject_GC_IS_TRACKED(function));
 
     if (function->m_annotations == NULL) {
-        function->m_annotations = MAKE_DICT_EMPTY();
+        PyThreadState *tstate = PyThreadState_GET();
+
+        function->m_annotations = MAKE_DICT_EMPTY(tstate);
     }
     CHECK_OBJECT(function->m_annotations);
 
@@ -520,13 +523,19 @@ static PyObject *Nuitka_Function_get_builtins(struct Nuitka_FunctionObject *func
 #if PYTHON_VERSION >= 0x3c0
 static int Nuitka_Function_set_type_params(struct Nuitka_FunctionObject *function, PyObject *value) {
     CHECK_OBJECT((PyObject *)function);
+    CHECK_OBJECT_X(value);
     assert(Nuitka_Function_Check((PyObject *)function));
     assert(_PyObject_GC_IS_TRACKED(function));
 
-    PyThreadState *tstate = PyThreadState_GET();
+    if (unlikely(value == NULL || !PyTuple_Check(value))) {
+        PyThreadState *tstate = PyThreadState_GET();
 
-    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "readonly attribute");
-    return -1;
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "__type_params__ must be set to a tuple");
+        return -1;
+    }
+
+    Py_SETREF(function->m_type_params, Py_NewRef(value));
+    return 0;
 }
 
 static PyObject *Nuitka_Function_get_type_params(struct Nuitka_FunctionObject *function) {
@@ -547,7 +556,9 @@ static int Nuitka_Function_set_module(struct Nuitka_FunctionObject *function, Py
     CHECK_OBJECT_X(value);
 
     if (function->m_dict == NULL) {
-        function->m_dict = MAKE_DICT_EMPTY();
+        NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
+        function->m_dict = MAKE_DICT_EMPTY(tstate);
     }
 
     if (value == NULL) {
@@ -663,10 +674,12 @@ static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function) {
     PRINT_NEW_LINE();
 #endif
 
+    PyThreadState *tstate = PyThreadState_GET();
+
     PyObject *annotations = function->m_annotations;
     if (annotations != NULL) {
         if (DICT_SIZE(annotations) != 0) {
-            annotations = DICT_COPY(annotations);
+            annotations = DICT_COPY(tstate, annotations);
         } else {
             annotations = NULL;
         }
@@ -675,7 +688,7 @@ static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function) {
     PyObject *kwdefaults = function->m_kwdefaults;
     if (kwdefaults != NULL) {
         if (DICT_SIZE(kwdefaults) != 0) {
-            kwdefaults = DICT_COPY(kwdefaults);
+            kwdefaults = DICT_COPY(tstate, kwdefaults);
         } else {
             kwdefaults = NULL;
         }
@@ -729,6 +742,10 @@ static void Nuitka_Function_tp_dealloc(struct Nuitka_FunctionObject *function) {
     Py_DECREF(function->m_qualname);
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+    Py_DECREF(function->m_type_params);
+#endif
+
     // These may actually resurrect the object, not?
     Py_XDECREF(function->m_dict);
     Py_DECREF(function->m_defaults);
@@ -1004,7 +1021,7 @@ static PyObject *_Nuitka_FunctionEmptyCodeTrueImpl(PyThreadState *tstate, struct
 
     PyObject *result = Py_True;
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -1021,8 +1038,7 @@ static PyObject *_Nuitka_FunctionEmptyCodeFalseImpl(PyThreadState *tstate, struc
     }
 
     PyObject *result = Py_False;
-
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -1248,7 +1264,7 @@ struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyO
 #endif
 
     if (defaults == NULL) {
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         defaults = Py_None;
     }
     CHECK_OBJECT(defaults);
@@ -1318,6 +1334,11 @@ struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyO
     result->m_vectorcall = (vectorcallfunc)Nuitka_Function_tp_vectorcall;
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+    result->m_type_params = const_tuple_empty;
+    assert(_Py_IsImmortal(result->m_type_params));
+#endif
+
     Nuitka_GC_Track(result);
 
     assert(Py_REFCNT(result) == 1);
@@ -1885,7 +1906,7 @@ static Py_ssize_t handleKeywordArgsSplit(struct Nuitka_FunctionObject const *fun
     return kw_found;
 }
 
-static PyObject *COPY_DICT_KW(PyObject *dict_value);
+static PyObject *COPY_DICT_KW(PyThreadState *tstate, PyObject *dict_value);
 
 static bool MAKE_STAR_DICT_DICTIONARY_COPY(PyThreadState *tstate, struct Nuitka_FunctionObject const *function,
                                            PyObject **python_pars, PyObject *kw) {
@@ -1893,9 +1914,9 @@ static bool MAKE_STAR_DICT_DICTIONARY_COPY(PyThreadState *tstate, struct Nuitka_
     assert(star_dict_index != -1);
 
     if (kw == NULL || ((PyDictObject *)kw)->ma_used == 0) {
-        python_pars[star_dict_index] = MAKE_DICT_EMPTY();
+        python_pars[star_dict_index] = MAKE_DICT_EMPTY(tstate);
     } else {
-        python_pars[star_dict_index] = COPY_DICT_KW(kw);
+        python_pars[star_dict_index] = COPY_DICT_KW(tstate, kw);
 
         if (unlikely(python_pars[star_dict_index] == NULL)) {
             formatErrorKeywordsMustBeString(tstate, function);
@@ -2026,30 +2047,30 @@ static Py_ssize_t handleKeywordArgsSplitWithStarDict(PyThreadState *tstate,
     return kw_found;
 }
 
-static void makeStarListTupleCopy(struct Nuitka_FunctionObject const *function, PyObject **python_pars,
-                                  PyObject *const *args, Py_ssize_t args_size) {
+static void makeStarListTupleCopy(PyThreadState *tstate, struct Nuitka_FunctionObject const *function,
+                                  PyObject **python_pars, PyObject *const *args, Py_ssize_t args_size) {
     assert(function->m_args_star_list_index != -1);
     Py_ssize_t list_star_index = function->m_args_star_list_index;
 
     // Copy left-over argument values to the star list parameter given.
     if (args_size > function->m_args_positional_count) {
         python_pars[list_star_index] =
-            MAKE_TUPLE(&args[function->m_args_positional_count], args_size - function->m_args_positional_count);
+            MAKE_TUPLE(tstate, &args[function->m_args_positional_count], args_size - function->m_args_positional_count);
     } else {
         python_pars[list_star_index] = const_tuple_empty;
         Py_INCREF(const_tuple_empty);
     }
 }
 
-static void makeStarListTupleCopyMethod(struct Nuitka_FunctionObject const *function, PyObject **python_pars,
-                                        PyObject *const *args, Py_ssize_t args_size) {
+static void makeStarListTupleCopyMethod(PyThreadState *tstate, struct Nuitka_FunctionObject const *function,
+                                        PyObject **python_pars, PyObject *const *args, Py_ssize_t args_size) {
     assert(function->m_args_star_list_index != -1);
     Py_ssize_t list_star_index = function->m_args_star_list_index;
 
     // Copy left-over argument values to the star list parameter given.
     if (args_size + 1 > function->m_args_positional_count) {
-        python_pars[list_star_index] =
-            MAKE_TUPLE(&args[function->m_args_positional_count - 1], args_size + 1 - function->m_args_positional_count);
+        python_pars[list_star_index] = MAKE_TUPLE(tstate, &args[function->m_args_positional_count - 1],
+                                                  args_size + 1 - function->m_args_positional_count);
     } else {
         python_pars[list_star_index] = const_tuple_empty;
         Py_INCREF(const_tuple_empty);
@@ -2137,7 +2158,7 @@ static bool _handleArgumentsPlainOnly(PyThreadState *tstate, struct Nuitka_Funct
 #endif
 
     if (function->m_args_star_list_index != -1) {
-        makeStarListTupleCopy(function, python_pars, args, args_size);
+        makeStarListTupleCopy(tstate, function, python_pars, args, args_size);
     }
 
     return true;
@@ -2156,7 +2177,7 @@ static bool handleMethodArgumentsPlainOnly(PyThreadState *tstate, struct Nuitka_
         // Without self, there can only be star list to get the object as its
         // first element. Or we complain about illegal arguments.
         if (function->m_args_star_list_index == 0) {
-            python_pars[0] = MAKE_TUPLE_EMPTY(args_size + 1);
+            python_pars[0] = MAKE_TUPLE_EMPTY(tstate, args_size + 1);
             PyTuple_SET_ITEM0(python_pars[0], 0, object);
 
             for (Py_ssize_t i = 0; i < args_size; i++) {
@@ -2241,7 +2262,7 @@ static bool handleMethodArgumentsPlainOnly(PyThreadState *tstate, struct Nuitka_
 #endif
 
     if (function->m_args_star_list_index != -1) {
-        makeStarListTupleCopyMethod(function, python_pars, args, args_size);
+        makeStarListTupleCopyMethod(tstate, function, python_pars, args, args_size);
     }
 
     return true;
@@ -2371,7 +2392,7 @@ static bool _handleArgumentsPlain(PyThreadState *tstate, struct Nuitka_FunctionO
 #endif
 
     if (function->m_args_star_list_index != -1) {
-        makeStarListTupleCopy(function, python_pars, args, args_size);
+        makeStarListTupleCopy(tstate, function, python_pars, args, args_size);
     }
 
     return true;
@@ -2438,7 +2459,7 @@ static bool parseArgumentsPos(PyThreadState *tstate, struct Nuitka_FunctionObjec
 #endif
 
     if (function->m_args_star_dict_index != -1) {
-        python_pars[function->m_args_star_dict_index] = MAKE_DICT_EMPTY();
+        python_pars[function->m_args_star_dict_index] = MAKE_DICT_EMPTY(tstate);
     }
 
     return true;
@@ -2490,7 +2511,7 @@ static bool parseArgumentsMethodPos(PyThreadState *tstate, struct Nuitka_Functio
 #endif
 
     if (function->m_args_star_dict_index != -1) {
-        python_pars[function->m_args_star_dict_index] = MAKE_DICT_EMPTY();
+        python_pars[function->m_args_star_dict_index] = MAKE_DICT_EMPTY(tstate);
     }
 
     return true;