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

nuitka/build/static_src/CompiledFunctionType.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 function type.
 
 // The backbone of the integration into CPython. Try to behave as well as normal
@@ -27,14 +12,22 @@
 #include "nuitka/freelists.h"
 
 // Needed for offsetof
-#include "structmember.h"
 #include <stddef.h>
+#include <structmember.h>
 
-// spell-checker: ignore qualname,klass,kwdefaults,getset,weakrefs,vectorcall,nargsf,m_varnames
+// spell-checker: ignore qualname,kwdefaults,getset,weakrefs,vectorcall,nargsf,m_varnames
+
+#if _DEBUG_REFCOUNTS
+int count_active_Nuitka_Function_Type;
+int count_allocated_Nuitka_Function_Type;
+int count_released_Nuitka_Function_Type;
+#endif
 
 // tp_descr_get slot, bind a function to an object.
-static PyObject *Nuitka_Function_descr_get(PyObject *function, PyObject *object, PyObject *klass) {
+static PyObject *Nuitka_Function_descr_get(PyObject *function, PyObject *object, PyObject *class_object) {
     assert(Nuitka_Function_Check(function));
+    CHECK_OBJECT((PyObject *)function);
+    assert(_PyObject_GC_IS_TRACKED(function));
 
 #if PYTHON_VERSION >= 0x300
     if (object == NULL || object == Py_None) {
@@ -43,7 +36,7 @@ static PyObject *Nuitka_Function_descr_get(PyObject *function, PyObject *object,
     }
 #endif
 
-    return Nuitka_Method_New((struct Nuitka_FunctionObject *)function, object == Py_None ? NULL : object, klass);
+    return Nuitka_Method_New((struct Nuitka_FunctionObject *)function, object == Py_None ? NULL : object, class_object);
 }
 
 // tp_repr slot, decide how compiled function shall be output to "repr" built-in
@@ -52,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) {
@@ -85,11 +76,12 @@ static long Nuitka_Function_tp_hash(struct Nuitka_FunctionObject *function) {
     return function->m_counter;
 }
 
-static PyObject *Nuitka_Function_get_name(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_name(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = function->m_name;
     CHECK_OBJECT(result);
 
@@ -97,10 +89,10 @@ static PyObject *Nuitka_Function_get_name(struct Nuitka_FunctionObject *function
     return result;
 }
 
-static int Nuitka_Function_set_name(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_name(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
 #if PYTHON_VERSION < 0x300
@@ -115,6 +107,7 @@ static int Nuitka_Function_set_name(struct Nuitka_FunctionObject *function, PyOb
         return -1;
     }
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_name;
     CHECK_OBJECT(old);
 
@@ -126,11 +119,12 @@ static int Nuitka_Function_set_name(struct Nuitka_FunctionObject *function, PyOb
 }
 
 #if PYTHON_VERSION >= 0x300
-static PyObject *Nuitka_Function_get_qualname(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_qualname(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = function->m_qualname;
     CHECK_OBJECT(result);
 
@@ -138,10 +132,10 @@ static PyObject *Nuitka_Function_get_qualname(struct Nuitka_FunctionObject *func
     return result;
 }
 
-static int Nuitka_Function_set_qualname(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_qualname(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
     if (unlikely(value == NULL || PyUnicode_Check(value) == 0)) {
@@ -151,6 +145,7 @@ static int Nuitka_Function_set_qualname(struct Nuitka_FunctionObject *function,
         return -1;
     }
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_qualname;
     Py_INCREF(value);
     function->m_qualname = value;
@@ -160,11 +155,12 @@ static int Nuitka_Function_set_qualname(struct Nuitka_FunctionObject *function,
 }
 #endif
 
-static PyObject *Nuitka_Function_get_doc(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_doc(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = function->m_doc;
 
     if (result == NULL) {
@@ -177,12 +173,13 @@ static PyObject *Nuitka_Function_get_doc(struct Nuitka_FunctionObject *function)
     return result;
 }
 
-static int Nuitka_Function_set_doc(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_doc(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_doc;
 
     function->m_doc = value;
@@ -193,13 +190,16 @@ static int Nuitka_Function_set_doc(struct Nuitka_FunctionObject *function, PyObj
     return 0;
 }
 
-static PyObject *Nuitka_Function_get_dict(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_dict(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     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);
@@ -208,10 +208,10 @@ static PyObject *Nuitka_Function_get_dict(struct Nuitka_FunctionObject *function
     return function->m_dict;
 }
 
-static int Nuitka_Function_set_dict(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_dict(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
     if (unlikely(value == NULL)) {
@@ -222,6 +222,7 @@ static int Nuitka_Function_set_dict(struct Nuitka_FunctionObject *function, PyOb
     }
 
     if (likely(PyDict_Check(value))) {
+        struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
         PyObject *old = function->m_dict;
         CHECK_OBJECT_X(old);
 
@@ -238,30 +239,31 @@ static int Nuitka_Function_set_dict(struct Nuitka_FunctionObject *function, PyOb
     }
 }
 
-static PyObject *Nuitka_Function_get_code(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_code(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = (PyObject *)function->m_code_object;
     Py_INCREF(result);
     return result;
 }
 
-static int Nuitka_Function_set_code(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_code(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "__code__ is not writable in Nuitka");
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_compiled(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_compiled(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyObject *result = Nuitka_dunder_compiled_value;
     CHECK_OBJECT(result);
@@ -270,21 +272,22 @@ static PyObject *Nuitka_Function_get_compiled(struct Nuitka_FunctionObject *func
     return result;
 }
 
-static int Nuitka_Function_set_compiled(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_compiled(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "__compiled__ is not writable");
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_compiled_constant(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_compiled_constant(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = function->m_constant_return_value;
 
     if (result == NULL) {
@@ -295,14 +298,14 @@ static PyObject *Nuitka_Function_get_compiled_constant(struct Nuitka_FunctionObj
     }
     CHECK_OBJECT(result);
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
-static int Nuitka_Function_set_compiled_constant(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_compiled_constant(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -310,23 +313,25 @@ static int Nuitka_Function_set_compiled_constant(struct Nuitka_FunctionObject *f
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_closure(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_closure(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     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;
     }
 }
 
-static int Nuitka_Function_set_closure(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_closure(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -341,11 +346,12 @@ static int Nuitka_Function_set_closure(struct Nuitka_FunctionObject *function, P
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_defaults(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_defaults(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = (PyObject *)function->m_defaults;
     CHECK_OBJECT(result);
 
@@ -364,10 +370,10 @@ static void _onUpdatedCompiledFunctionDefaultsValue(struct Nuitka_FunctionObject
     }
 }
 
-static int Nuitka_Function_set_defaults(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_defaults(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
     if (value == NULL) {
@@ -381,6 +387,7 @@ static int Nuitka_Function_set_defaults(struct Nuitka_FunctionObject *function,
         return -1;
     }
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_defaults;
     CHECK_OBJECT(old);
 
@@ -394,11 +401,12 @@ static int Nuitka_Function_set_defaults(struct Nuitka_FunctionObject *function,
 }
 
 #if PYTHON_VERSION >= 0x300
-static PyObject *Nuitka_Function_get_kwdefaults(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_kwdefaults(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = function->m_kwdefaults;
     CHECK_OBJECT_X(result);
 
@@ -410,10 +418,10 @@ static PyObject *Nuitka_Function_get_kwdefaults(struct Nuitka_FunctionObject *fu
     return result;
 }
 
-static int Nuitka_Function_set_kwdefaults(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_kwdefaults(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
     if (value == NULL) {
@@ -431,6 +439,7 @@ static int Nuitka_Function_set_kwdefaults(struct Nuitka_FunctionObject *function
         value = NULL;
     }
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_kwdefaults;
     CHECK_OBJECT_X(old);
 
@@ -441,13 +450,16 @@ static int Nuitka_Function_set_kwdefaults(struct Nuitka_FunctionObject *function
     return 0;
 }
 
-static PyObject *Nuitka_Function_get_annotations(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_annotations(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     if (function->m_annotations == NULL) {
-        function->m_annotations = MAKE_DICT_EMPTY();
+        NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
+        function->m_annotations = MAKE_DICT_EMPTY(tstate);
     }
     CHECK_OBJECT(function->m_annotations);
 
@@ -455,10 +467,10 @@ static PyObject *Nuitka_Function_get_annotations(struct Nuitka_FunctionObject *f
     return function->m_annotations;
 }
 
-static int Nuitka_Function_set_annotations(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_annotations(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     if (unlikely(value != NULL && PyDict_Check(value) == false)) {
         PyThreadState *tstate = PyThreadState_GET();
@@ -467,6 +479,7 @@ static int Nuitka_Function_set_annotations(struct Nuitka_FunctionObject *functio
         return -1;
     }
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *old = function->m_annotations;
     CHECK_OBJECT_X(old);
 
@@ -479,10 +492,10 @@ static int Nuitka_Function_set_annotations(struct Nuitka_FunctionObject *functio
 
 #endif
 
-static int Nuitka_Function_set_globals(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_globals(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -490,11 +503,12 @@ static int Nuitka_Function_set_globals(struct Nuitka_FunctionObject *function, P
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_globals(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_globals(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     PyObject *result = PyModule_GetDict(function->m_module);
     CHECK_OBJECT(result);
 
@@ -503,10 +517,10 @@ static PyObject *Nuitka_Function_get_globals(struct Nuitka_FunctionObject *funct
 }
 
 #if PYTHON_VERSION >= 0x3a0
-static int Nuitka_Function_set_builtins(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static int Nuitka_Function_set_builtins(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -514,24 +528,58 @@ static int Nuitka_Function_set_builtins(struct Nuitka_FunctionObject *function,
     return -1;
 }
 
-static PyObject *Nuitka_Function_get_builtins(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_builtins(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyThreadState *tstate = PyThreadState_GET();
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     return LOOKUP_SUBSCRIPT(tstate, PyModule_GetDict(function->m_module), const_str_plain___builtins__);
 }
 #endif
 
-static int Nuitka_Function_set_module(struct Nuitka_FunctionObject *function, PyObject *value) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+#if PYTHON_VERSION >= 0x3c0
+static int Nuitka_Function_set_type_params(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    CHECK_OBJECT_X(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
+
+    if (unlikely(value == NULL || !PyTuple_Check(value))) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "__type_params__ must be set to a tuple");
+        return -1;
+    }
+
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
+    Py_SETREF(function->m_type_params, Py_NewRef(value));
+    return 0;
+}
+
+static PyObject *Nuitka_Function_get_type_params(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
+
+    // TODO: Probably not needed anymore?
+    Py_INCREF(const_tuple_empty);
+    return const_tuple_empty;
+}
+#endif
+
+static int Nuitka_Function_set_module(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
     CHECK_OBJECT_X(value);
 
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     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) {
@@ -541,16 +589,17 @@ static int Nuitka_Function_set_module(struct Nuitka_FunctionObject *function, Py
     return DICT_SET_ITEM(function->m_dict, const_str_plain___module__, value) ? 0 : -1;
 }
 
-static PyObject *Nuitka_Function_get_module(struct Nuitka_FunctionObject *function) {
-    CHECK_OBJECT((PyObject *)function);
-    assert(Nuitka_Function_Check((PyObject *)function));
-    assert(_PyObject_GC_IS_TRACKED(function));
+static PyObject *Nuitka_Function_get_module(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
+    assert(Nuitka_Function_Check(self));
+    assert(_PyObject_GC_IS_TRACKED(self));
 
     PyObject *result;
 
     PyThreadState *tstate = PyThreadState_GET();
 
     // The __dict__ might overrule this.
+    struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)self;
     if (function->m_dict) {
         result = DICT_GET_ITEM1(tstate, function->m_dict, const_str_plain___module__);
 
@@ -565,50 +614,53 @@ static PyObject *Nuitka_Function_get_module(struct Nuitka_FunctionObject *functi
 
 static PyGetSetDef Nuitka_Function_getset[] = {
 #if PYTHON_VERSION >= 0x300
-    {(char *)"__qualname__", (getter)Nuitka_Function_get_qualname, (setter)Nuitka_Function_set_qualname, NULL},
+    {(char *)"__qualname__", Nuitka_Function_get_qualname, Nuitka_Function_set_qualname, NULL},
 #endif
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_name", (getter)Nuitka_Function_get_name, (setter)Nuitka_Function_set_name, NULL},
+    {(char *)"func_name", Nuitka_Function_get_name, Nuitka_Function_set_name, NULL},
 #endif
-    {(char *)"__name__", (getter)Nuitka_Function_get_name, (setter)Nuitka_Function_set_name, NULL},
+    {(char *)"__name__", Nuitka_Function_get_name, Nuitka_Function_set_name, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_doc", (getter)Nuitka_Function_get_doc, (setter)Nuitka_Function_set_doc, NULL},
+    {(char *)"func_doc", Nuitka_Function_get_doc, Nuitka_Function_set_doc, NULL},
 #endif
-    {(char *)"__doc__", (getter)Nuitka_Function_get_doc, (setter)Nuitka_Function_set_doc, NULL},
+    {(char *)"__doc__", Nuitka_Function_get_doc, Nuitka_Function_set_doc, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_dict", (getter)Nuitka_Function_get_dict, (setter)Nuitka_Function_set_dict, NULL},
+    {(char *)"func_dict", Nuitka_Function_get_dict, Nuitka_Function_set_dict, NULL},
 #endif
-    {(char *)"__dict__", (getter)Nuitka_Function_get_dict, (setter)Nuitka_Function_set_dict, NULL},
+    {(char *)"__dict__", Nuitka_Function_get_dict, Nuitka_Function_set_dict, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_code", (getter)Nuitka_Function_get_code, (setter)Nuitka_Function_set_code, NULL},
+    {(char *)"func_code", Nuitka_Function_get_code, Nuitka_Function_set_code, NULL},
 #endif
-    {(char *)"__code__", (getter)Nuitka_Function_get_code, (setter)Nuitka_Function_set_code, NULL},
+    {(char *)"__code__", Nuitka_Function_get_code, Nuitka_Function_set_code, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_defaults", (getter)Nuitka_Function_get_defaults, (setter)Nuitka_Function_set_defaults, NULL},
+    {(char *)"func_defaults", Nuitka_Function_get_defaults, Nuitka_Function_set_defaults, NULL},
 #endif
-    {(char *)"__defaults__", (getter)Nuitka_Function_get_defaults, (setter)Nuitka_Function_set_defaults, NULL},
+    {(char *)"__defaults__", Nuitka_Function_get_defaults, Nuitka_Function_set_defaults, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_globals", (getter)Nuitka_Function_get_globals, (setter)Nuitka_Function_set_globals, NULL},
+    {(char *)"func_globals", Nuitka_Function_get_globals, Nuitka_Function_set_globals, NULL},
 #endif
-    {(char *)"__closure__", (getter)Nuitka_Function_get_closure, (setter)Nuitka_Function_set_closure, NULL},
+    {(char *)"__closure__", Nuitka_Function_get_closure, Nuitka_Function_set_closure, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"func_closure", (getter)Nuitka_Function_get_closure, (setter)Nuitka_Function_set_closure, NULL},
+    {(char *)"func_closure", Nuitka_Function_get_closure, Nuitka_Function_set_closure, NULL},
 #endif
-    {(char *)"__globals__", (getter)Nuitka_Function_get_globals, (setter)Nuitka_Function_set_globals, NULL},
-    {(char *)"__module__", (getter)Nuitka_Function_get_module, (setter)Nuitka_Function_set_module, NULL},
+    {(char *)"__globals__", Nuitka_Function_get_globals, Nuitka_Function_set_globals, NULL},
+    {(char *)"__module__", Nuitka_Function_get_module, Nuitka_Function_set_module, NULL},
 #if PYTHON_VERSION >= 0x300
-    {(char *)"__kwdefaults__", (getter)Nuitka_Function_get_kwdefaults, (setter)Nuitka_Function_set_kwdefaults, NULL},
-    {(char *)"__annotations__", (getter)Nuitka_Function_get_annotations, (setter)Nuitka_Function_set_annotations, NULL},
+    {(char *)"__kwdefaults__", Nuitka_Function_get_kwdefaults, Nuitka_Function_set_kwdefaults, NULL},
+    {(char *)"__annotations__", Nuitka_Function_get_annotations, Nuitka_Function_set_annotations, NULL},
 #endif
 #if PYTHON_VERSION >= 0x3a0
-    {(char *)"__builtins__", (getter)Nuitka_Function_get_builtins, (setter)Nuitka_Function_set_builtins, NULL},
+    {(char *)"__builtins__", Nuitka_Function_get_builtins, Nuitka_Function_set_builtins, NULL},
+#endif
+#if PYTHON_VERSION >= 0x3c0
+    {(char *)"__type_params__", Nuitka_Function_get_type_params, Nuitka_Function_set_type_params, NULL},
 #endif
-    {(char *)"__compiled__", (getter)Nuitka_Function_get_compiled, (setter)Nuitka_Function_set_compiled, NULL},
-    {(char *)"__compiled_constant__", (getter)Nuitka_Function_get_compiled_constant,
-     (setter)Nuitka_Function_set_compiled_constant, NULL},
+    {(char *)"__compiled__", Nuitka_Function_get_compiled, Nuitka_Function_set_compiled, NULL},
+    {(char *)"__compiled_constant__", Nuitka_Function_get_compiled_constant, Nuitka_Function_set_compiled_constant,
+     NULL},
     {NULL}};
 
-static PyObject *Nuitka_Function_reduce(struct Nuitka_FunctionObject *function) {
+static PyObject *Nuitka_Function_reduce(struct Nuitka_FunctionObject *function, PyObject *unused) {
     CHECK_OBJECT((PyObject *)function);
     assert(Nuitka_Function_Check((PyObject *)function));
     assert(_PyObject_GC_IS_TRACKED(function));
@@ -625,11 +677,46 @@ static PyObject *Nuitka_Function_reduce(struct Nuitka_FunctionObject *function)
     return result;
 }
 
-static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function) {
+static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function, PyObject *unused) {
     CHECK_OBJECT((PyObject *)function);
     assert(Nuitka_Function_Check((PyObject *)function));
     assert(_PyObject_GC_IS_TRACKED(function));
 
+    for (Py_ssize_t i = 0; i < function->m_closure_given; i++) {
+        assert(function->m_closure[i]);
+        Py_INCREF(function->m_closure[i]);
+    }
+
+    Py_INCREF(function->m_defaults);
+
+#if PYTHON_VERSION >= 0x300
+#if 0
+    PRINT_STRING("Nuitka_Function_clone:");
+    PRINT_ITEM((PyObject *)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(tstate, annotations);
+        } else {
+            annotations = NULL;
+        }
+    }
+
+    PyObject *kwdefaults = function->m_kwdefaults;
+    if (kwdefaults != NULL) {
+        if (DICT_SIZE(kwdefaults) != 0) {
+            kwdefaults = DICT_COPY(tstate, kwdefaults);
+        } else {
+            kwdefaults = NULL;
+        }
+    }
+#endif
+
     struct Nuitka_FunctionObject *result =
         Nuitka_Function_New(function->m_c_code, function->m_name,
 #if PYTHON_VERSION >= 0x300
@@ -637,7 +724,7 @@ static PyObject *Nuitka_Function_clone(struct Nuitka_FunctionObject *function) {
 #endif
                             function->m_code_object, function->m_defaults,
 #if PYTHON_VERSION >= 0x300
-                            function->m_kwdefaults, function->m_annotations,
+                            kwdefaults, annotations,
 #endif
                             function->m_module, function->m_doc, function->m_closure, function->m_closure_given);
 
@@ -649,6 +736,11 @@ static struct Nuitka_FunctionObject *free_list_functions = NULL;
 static int free_list_functions_count = 0;
 
 static void Nuitka_Function_tp_dealloc(struct Nuitka_FunctionObject *function) {
+#if _DEBUG_REFCOUNTS
+    count_active_Nuitka_Function_Type -= 1;
+    count_released_Nuitka_Function_Type += 1;
+#endif
+
     assert(Nuitka_Function_Check((PyObject *)function));
     assert(_PyObject_GC_IS_TRACKED(function));
 
@@ -656,10 +748,9 @@ static void Nuitka_Function_tp_dealloc(struct Nuitka_FunctionObject *function) {
     PyThreadState *tstate = PyThreadState_GET();
 
     // Save the current exception, if any, we must to not corrupt 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);
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state1;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
 #endif
     assert(_PyObject_GC_IS_TRACKED(function));
     Nuitka_GC_UnTrack(function);
@@ -673,6 +764,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);
@@ -696,9 +791,11 @@ static void Nuitka_Function_tp_dealloc(struct Nuitka_FunctionObject *function) {
     releaseToFreeList(free_list_functions, function, MAX_FUNCTION_FREE_LIST_COUNT);
 
 #ifndef __NUITKA_NO_ASSERT__
-    assert(tstate->curexc_type == save_exception_type);
-    assert(tstate->curexc_value == save_exception_value);
-    assert((PyTracebackObject *)tstate->curexc_traceback == save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state2;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+
+    ASSERT_SAME_EXCEPTION_STATE(&saved_exception_state1, &saved_exception_state2);
 #endif
 }
 
@@ -766,7 +863,7 @@ PyTypeObject Nuitka_Function_Type = {
     0,                                                  // tp_weaklist
     0,                                                  // tp_del
     0                                                   // tp_version_tag
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     ,
     0 // tp_finalizer
 #endif
@@ -803,7 +900,7 @@ void _initCompiledFunctionType(void) {
     assert(Nuitka_Function_Type.tp_subclasses != PyFunction_Type.tp_subclasses || PyFunction_Type.tp_cache == NULL);
     assert(Nuitka_Function_Type.tp_weaklist != PyFunction_Type.tp_weaklist);
     assert(Nuitka_Function_Type.tp_del != PyFunction_Type.tp_del || PyFunction_Type.tp_del == NULL);
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     assert(Nuitka_Function_Type.tp_finalize != PyFunction_Type.tp_finalize || PyFunction_Type.tp_finalize == NULL);
 #endif
 
@@ -909,11 +1006,6 @@ void _initCompiledFunctionType(void) {
         }
     }
 #endif
-
-#ifdef _NUITKA_PLUGIN_DILL_ENABLED
-    // TODO: Move this to a __nuitka__ module maybe
-    PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function", (PyObject *)&Nuitka_Function_Type);
-#endif
 }
 
 // Shared implementations for empty functions. When a function body is empty, but
@@ -951,7 +1043,7 @@ static PyObject *_Nuitka_FunctionEmptyCodeTrueImpl(PyThreadState *tstate, struct
 
     PyObject *result = Py_True;
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -968,8 +1060,7 @@ static PyObject *_Nuitka_FunctionEmptyCodeFalseImpl(PyThreadState *tstate, struc
     }
 
     PyObject *result = Py_False;
-
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -988,7 +1079,7 @@ static PyObject *_Nuitka_FunctionEmptyCodeGenericImpl(PyThreadState *tstate,
 
     PyObject *result = function->m_constant_return_value;
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -1007,6 +1098,180 @@ void Nuitka_Function_EnableConstReturnGeneric(struct Nuitka_FunctionObject *func
     function->m_c_code = _Nuitka_FunctionEmptyCodeGenericImpl;
 }
 
+#ifdef _NUITKA_PLUGIN_DILL_ENABLED
+int Nuitka_Function_GetFunctionCodeIndex(struct Nuitka_FunctionObject *function,
+                                         function_impl_code const *function_table) {
+
+    if (function->m_c_code == _Nuitka_FunctionEmptyCodeTrueImpl) {
+        return -2;
+    }
+
+    if (function->m_c_code == _Nuitka_FunctionEmptyCodeFalseImpl) {
+        return -3;
+    }
+
+    if (function->m_c_code == _Nuitka_FunctionEmptyCodeNoneImpl) {
+        return -4;
+    }
+
+    if (function->m_c_code == _Nuitka_FunctionEmptyCodeGenericImpl) {
+        return -5;
+    }
+
+    function_impl_code const *current = function_table;
+    int offset = 0;
+
+    while (*current != NULL) {
+        if (*current == function->m_c_code) {
+            break;
+        }
+
+        current += 1;
+        offset += 1;
+    }
+
+    if (*current == NULL) {
+        PyThreadState *tstate = PyThreadState_GET();
+#if 0
+        PRINT_STRING("Looking for:");
+        PRINT_ITEM((PyObject *)function);
+        PRINT_NEW_LINE();
+#endif
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "Cannot find compiled function in module.");
+        return -1;
+    }
+
+    return offset;
+}
+
+struct Nuitka_FunctionObject *
+Nuitka_Function_CreateFunctionViaCodeIndex(PyObject *module, PyObject *function_qualname, PyObject *function_index,
+                                           PyObject *code_object_desc, PyObject *constant_return_value,
+                                           PyObject *defaults, PyObject *kw_defaults, PyObject *doc, PyObject *closure,
+                                           function_impl_code const *function_table, int function_table_size) {
+    int offset = PyLong_AsLong(function_index);
+
+    if (offset > function_table_size || offset < -5 || offset == -1) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "Wrong offset for compiled function.");
+        return NULL;
+    }
+
+    PyObject *filename = PyTuple_GET_ITEM(code_object_desc, 0);
+    PyObject *function_name = PyTuple_GET_ITEM(code_object_desc, 1);
+    PyObject *line = PyTuple_GET_ITEM(code_object_desc, 2);
+    int line_int = PyLong_AsLong(line);
+    assert(line_int != -1);
+
+    PyObject *arg_names = PyTuple_GET_ITEM(code_object_desc, 3);
+    PyObject *arg_count = PyTuple_GET_ITEM(code_object_desc, 4);
+    int arg_count_int = PyLong_AsLong(arg_count);
+    assert(arg_count_int != -1);
+
+    PyObject *flags = PyTuple_GET_ITEM(code_object_desc, 5);
+    int flags_int = PyLong_AsLong(flags);
+    assert(flags_int != -1);
+
+    PyObject *kw_only_count = PyTuple_GET_ITEM(code_object_desc, 6);
+    int kw_only_count_int = PyLong_AsLong(kw_only_count);
+    assert(kw_only_count_int != -1);
+
+    PyObject *pos_only_count = PyTuple_GET_ITEM(code_object_desc, 7);
+    int pos_only_count_int = PyLong_AsLong(pos_only_count);
+    assert(pos_only_count_int != -1);
+
+    PyCodeObject *code_object =
+        MAKE_CODE_OBJECT(filename, line_int, flags_int, function_name, function_qualname, arg_names,
+                         NULL, // free_vars
+                         arg_count_int, kw_only_count_int, pos_only_count_int);
+    if (unlikely(code_object == NULL)) {
+        return NULL;
+    }
+
+    Py_ssize_t closure_size;
+
+    if (closure != Py_None) {
+        closure_size = PyTuple_GET_SIZE(closure);
+    } else {
+        closure_size = 0;
+    }
+
+    NUITKA_DYNAMIC_ARRAY_DECL(closure_cells, struct Nuitka_CellObject *, closure_size);
+
+    for (Py_ssize_t i = 0; i < closure_size; i++) {
+        closure_cells[i] = Nuitka_Cell_New0(PyTuple_GET_ITEM(closure, i));
+    }
+
+    struct Nuitka_FunctionObject *result =
+        Nuitka_Function_New(offset >= 0 ? function_table[offset] : NULL, code_object->co_name,
+#if PYTHON_VERSION >= 0x300
+                            NULL, // TODO: Not transferring qualname yet
+#endif
+                            code_object, defaults,
+#if PYTHON_VERSION >= 0x300
+                            kw_defaults,
+                            NULL, // TODO: Not transferring annotations
+#endif
+                            module, doc, closure_cells, closure_size);
+
+    CHECK_OBJECT(result);
+
+    if (offset == -2) {
+        Nuitka_Function_EnableConstReturnTrue(result);
+    }
+    if (offset == -3) {
+        Nuitka_Function_EnableConstReturnFalse(result);
+    }
+    if (offset == -4) {
+        result->m_c_code = _Nuitka_FunctionEmptyCodeNoneImpl;
+    }
+    if (offset == -5) {
+        CHECK_OBJECT(constant_return_value);
+
+        Nuitka_Function_EnableConstReturnGeneric(result, constant_return_value);
+
+        Py_INCREF_IMMORTAL(constant_return_value);
+    }
+
+    assert(result->m_c_code != NULL);
+
+    return result;
+}
+
+PyObject *Nuitka_Function_ExtractCodeObjectDescription(PyThreadState *tstate, struct Nuitka_FunctionObject *function) {
+    PyObject *code_object_desc = MAKE_TUPLE_EMPTY(tstate, 8);
+
+    PyTuple_SET_ITEM0(code_object_desc, 0, function->m_code_object->co_filename);
+    PyTuple_SET_ITEM0(code_object_desc, 1, function->m_code_object->co_name);
+    PyTuple_SET_ITEM(code_object_desc, 2, Nuitka_PyLong_FromLong(function->m_code_object->co_firstlineno));
+#if PYTHON_VERSION < 0x3b0
+    PyTuple_SET_ITEM0(code_object_desc, 3, function->m_code_object->co_varnames);
+#else
+    // spell-checker: ignore PyCode_GetVarnames
+    PyTuple_SET_ITEM(code_object_desc, 3, PyCode_GetVarnames(function->m_code_object));
+#endif
+    PyTuple_SET_ITEM(code_object_desc, 4, Nuitka_PyLong_FromLong(function->m_code_object->co_argcount));
+    PyTuple_SET_ITEM(code_object_desc, 5, Nuitka_PyLong_FromLong(function->m_code_object->co_flags));
+
+#if PYTHON_VERSION < 0x380
+    PyTuple_SET_ITEM(code_object_desc, 6, const_int_0);
+#else
+    PyTuple_SET_ITEM(code_object_desc, 6, Nuitka_PyLong_FromLong(function->m_code_object->co_posonlyargcount));
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+    PyTuple_SET_ITEM(code_object_desc, 7, const_int_0);
+#else
+    PyTuple_SET_ITEM(code_object_desc, 7, Nuitka_PyLong_FromLong(function->m_code_object->co_kwonlyargcount));
+#endif
+
+    CHECK_OBJECT_DEEP(code_object_desc);
+
+    return code_object_desc;
+}
+#endif
+
 #if PYTHON_VERSION >= 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_VECTORCALL_SLOT)
 static PyObject *Nuitka_Function_tp_vectorcall(struct Nuitka_FunctionObject *function, PyObject *const *stack,
                                                size_t nargsf, PyObject *kw_names);
@@ -1019,16 +1284,23 @@ struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyO
                                                   struct Nuitka_CellObject **closure, Py_ssize_t closure_given)
 #else
 struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyObject *name, PyObject *qualname,
-                                                  PyCodeObject *code_object, PyObject *defaults, PyObject *kwdefaults,
+                                                  PyCodeObject *code_object, PyObject *defaults, PyObject *kw_defaults,
                                                   PyObject *annotations, PyObject *module, PyObject *doc,
                                                   struct Nuitka_CellObject **closure, Py_ssize_t closure_given)
 #endif
 {
+#if _DEBUG_REFCOUNTS
+    count_active_Nuitka_Function_Type += 1;
+    count_allocated_Nuitka_Function_Type += 1;
+#endif
+
     struct Nuitka_FunctionObject *result;
 
     // Macro to assign result memory from GC or free list.
     allocateFromFreeList(free_list_functions, struct Nuitka_FunctionObject, Nuitka_Function_Type, closure_given);
 
+    assert(closure_given == 0 || closure != NULL);
+
     memcpy(&result->m_closure[0], closure, closure_given * sizeof(struct Nuitka_CellObject *));
     result->m_closure_given = closure_given;
 
@@ -1055,7 +1327,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);
@@ -1065,8 +1337,8 @@ struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyO
     _onUpdatedCompiledFunctionDefaultsValue(result);
 
 #if PYTHON_VERSION >= 0x300
-    assert(kwdefaults == NULL || (PyDict_Check(kwdefaults) && DICT_SIZE(kwdefaults) > 0));
-    result->m_kwdefaults = kwdefaults;
+    assert(kw_defaults == NULL || (PyDict_Check(kw_defaults) && DICT_SIZE(kw_defaults) > 0));
+    result->m_kwdefaults = kw_defaults;
 
     assert(annotations == NULL || (PyDict_Check(annotations) && DICT_SIZE(annotations) > 0));
     result->m_annotations = annotations;
@@ -1125,6 +1397,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);
@@ -1357,11 +1634,11 @@ static void formatErrorTooFewKwOnlyArguments(PyThreadState *tstate, struct Nuitk
     char const *function_name = Nuitka_String_AsString(function->m_qualname);
 #endif
 
-    Py_ssize_t kwonlyargcount = function->m_code_object->co_kwonlyargcount;
+    Py_ssize_t co_kwonlyargcount = function->m_code_object->co_kwonlyargcount;
 
     Py_ssize_t max_missing = 0;
 
-    for (Py_ssize_t i = kwonlyargcount - 1; i >= 0; --i) {
+    for (Py_ssize_t i = co_kwonlyargcount - 1; i >= 0; --i) {
         if (kw_vars[i] == NULL) {
             max_missing += 1;
         }
@@ -1373,7 +1650,7 @@ static void formatErrorTooFewKwOnlyArguments(PyThreadState *tstate, struct Nuitk
     PyObject *and_str = PyUnicode_FromString(max_missing == 2 ? " and " : ", and ");
 
     Py_ssize_t missing = 0;
-    for (Py_ssize_t i = kwonlyargcount - 1; i >= 0; --i) {
+    for (Py_ssize_t i = co_kwonlyargcount - 1; i >= 0; --i) {
         if (kw_vars[i] == NULL) {
             PyObject *current_str = function->m_varnames[function->m_args_positional_count + i];
 
@@ -1384,28 +1661,53 @@ static void formatErrorTooFewKwOnlyArguments(PyThreadState *tstate, struct Nuitk
 
                 list_str = UNICODE_CONCAT(tstate, list_str, current);
 
+                if (unlikely(list_str == NULL)) {
+                    list_str = old;
+                    break;
+                }
+
                 Py_DECREF(old);
             } else if (missing == 1) {
                 PyObject *old = list_str;
 
                 list_str = UNICODE_CONCAT(tstate, and_str, list_str);
 
+                if (unlikely(list_str == NULL)) {
+                    list_str = old;
+                    break;
+                }
+
                 Py_DECREF(old);
                 old = list_str;
 
                 list_str = UNICODE_CONCAT(tstate, current, list_str);
 
+                if (unlikely(list_str == NULL)) {
+                    list_str = old;
+                    break;
+                }
+
                 Py_DECREF(old);
             } else {
                 PyObject *old = list_str;
 
                 list_str = UNICODE_CONCAT(tstate, comma_str, list_str);
 
+                if (unlikely(list_str == NULL)) {
+                    list_str = old;
+                    break;
+                }
+
                 Py_DECREF(old);
                 old = list_str;
 
                 list_str = UNICODE_CONCAT(tstate, current, list_str);
 
+                if (unlikely(list_str == NULL)) {
+                    list_str = old;
+                    break;
+                }
+
                 Py_DECREF(old);
             }
 
@@ -1519,10 +1821,10 @@ static Py_ssize_t handleKeywordArgs(PyThreadState *tstate, struct Nuitka_Functio
         }
 
         if (found == false) {
-            PyObject **varnames = function->m_varnames;
+            PyObject **var_names = function->m_varnames;
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = value;
 
@@ -1542,9 +1844,9 @@ static Py_ssize_t handleKeywordArgs(PyThreadState *tstate, struct Nuitka_Functio
             bool pos_only_error = false;
 
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
-                PyObject **varnames = function->m_varnames;
+                PyObject **var_names = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -1633,11 +1935,11 @@ static Py_ssize_t handleKeywordArgsSplit(struct Nuitka_FunctionObject const *fun
         }
 
         if (found == false) {
-            PyObject **varnames = function->m_varnames;
+            PyObject **var_names = function->m_varnames;
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
                 // TODO: Could do better here, STR/UNICODE key knowledge being there.
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = value;
 
@@ -1657,9 +1959,9 @@ static Py_ssize_t handleKeywordArgsSplit(struct Nuitka_FunctionObject const *fun
             bool pos_only_error = false;
 
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
-                PyObject **varnames = function->m_varnames;
+                PyObject **var_names = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -1692,7 +1994,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) {
@@ -1700,9 +2002,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);
@@ -1735,7 +2037,7 @@ static Py_ssize_t handleKeywordArgsWithStarDict(PyThreadState *tstate, struct Nu
 
     Py_ssize_t star_dict_index = function->m_args_star_dict_index;
 
-    PyObject **varnames = function->m_varnames;
+    PyObject **var_names = function->m_varnames;
 
 #if PYTHON_VERSION < 0x380
     Py_ssize_t kw_arg_start = 0;
@@ -1744,7 +2046,7 @@ static Py_ssize_t handleKeywordArgsWithStarDict(PyThreadState *tstate, struct Nu
 #endif
 
     for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-        PyObject *arg_name = varnames[i];
+        PyObject *arg_name = var_names[i];
 
         PyObject *kw_arg_value = DICT_GET_ITEM1(tstate, python_pars[star_dict_index], arg_name);
 
@@ -1800,7 +2102,7 @@ static Py_ssize_t handleKeywordArgsSplitWithStarDict(PyThreadState *tstate,
     Py_ssize_t keyword_after_index = function->m_args_positional_count;
 #endif
 
-    PyObject **varnames = function->m_varnames;
+    PyObject **var_names = function->m_varnames;
 
 #if PYTHON_VERSION < 0x380
     Py_ssize_t kw_arg_start = 0;
@@ -1809,7 +2111,7 @@ static Py_ssize_t handleKeywordArgsSplitWithStarDict(PyThreadState *tstate,
 #endif
 
     for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-        PyObject *arg_name = varnames[i];
+        PyObject *arg_name = var_names[i];
 
         PyObject *kw_arg_value = DICT_GET_ITEM1(tstate, python_pars[star_dict_index], arg_name);
 
@@ -1833,30 +2135,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);
@@ -1944,7 +2246,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;
@@ -1963,7 +2265,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++) {
@@ -2048,7 +2350,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;
@@ -2178,7 +2480,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;
@@ -2245,7 +2547,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;
@@ -2297,7 +2599,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;
@@ -2611,10 +2913,10 @@ static Py_ssize_t _handleVectorcallKeywordArgs(PyThreadState *tstate, struct Nui
         }
 
         if (found == false) {
-            PyObject **varnames = function->m_varnames;
+            PyObject **var_names = function->m_varnames;
 
             for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     assert(python_pars[i] == NULL);
                     python_pars[i] = kw_values[pos];
                     Py_INCREF(python_pars[i]);
@@ -2633,9 +2935,9 @@ static Py_ssize_t _handleVectorcallKeywordArgs(PyThreadState *tstate, struct Nui
             bool pos_only_error = false;
 
             for (Py_ssize_t i = 0; i < kw_arg_start; i++) {
-                PyObject **varnames = function->m_varnames;
+                PyObject **var_names = function->m_varnames;
 
-                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(varnames[i], key)) {
+                if (RICH_COMPARE_EQ_CBOOL_ARG_NAMES(var_names[i], key)) {
                     pos_only_error = true;
                     break;
                 }
@@ -2710,7 +3012,7 @@ static Py_ssize_t handleVectorcallKeywordArgsWithStarDict(PyThreadState *tstate,
 
     Py_ssize_t star_dict_index = function->m_args_star_dict_index;
 
-    PyObject **varnames = function->m_varnames;
+    PyObject **var_names = function->m_varnames;
 
 #if PYTHON_VERSION < 0x380
     Py_ssize_t kw_arg_start = 0;
@@ -2719,7 +3021,7 @@ static Py_ssize_t handleVectorcallKeywordArgsWithStarDict(PyThreadState *tstate,
 #endif
 
     for (Py_ssize_t i = kw_arg_start; i < keywords_count; i++) {
-        PyObject *arg_name = varnames[i];
+        PyObject *arg_name = var_names[i];
 
         PyObject *kw_arg_value = DICT_GET_ITEM1(tstate, python_pars[star_dict_index], arg_name);
 
@@ -2894,15 +3196,15 @@ static PyObject *Nuitka_Function_tp_call(struct Nuitka_FunctionObject *function,
 static PyObject *Nuitka_Function_tp_vectorcall(struct Nuitka_FunctionObject *function, PyObject *const *stack,
                                                size_t nargsf, PyObject *kw_names) {
     assert(kw_names == NULL || PyTuple_CheckExact(kw_names));
-    Py_ssize_t nkwargs = (kw_names == NULL) ? 0 : PyTuple_GET_SIZE(kw_names);
+    Py_ssize_t kwargs_count = (kw_names == NULL) ? 0 : PyTuple_GET_SIZE(kw_names);
 
     Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
     assert(nargs >= 0);
-    assert((nargs == 0 && nkwargs == 0) || stack != NULL);
+    assert((nargs == 0 && kwargs_count == 0) || stack != NULL);
 
     PyThreadState *tstate = PyThreadState_GET();
     return Nuitka_CallFunctionVectorcall(tstate, function, stack, nargs,
-                                         kw_names ? &PyTuple_GET_ITEM(kw_names, 0) : NULL, nkwargs);
+                                         kw_names ? &PyTuple_GET_ITEM(kw_names, 0) : NULL, kwargs_count);
 }
 #endif
 
@@ -2914,4 +3216,18 @@ static PyObject *Nuitka_Function_tp_vectorcall(struct Nuitka_FunctionObject *fun
 
 #include "CompiledCodeHelpers.c"
 
-#include "InspectPatcher.c"
+#include "InspectPatcher.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.