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

nuitka/build/static_src/CompiledMethodType.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 methods.
  *
  * It strives to be full replacement for normal method objects, but
@@ -27,6 +12,7 @@
 #ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
 #include "nuitka/prelude.h"
+#include <structmember.h>
 #endif
 
 static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, void *closure) {
@@ -40,8 +26,8 @@ static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, vo
     return result;
 }
 
-static PyGetSetDef Nuitka_Method_getsets[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
-                                              {NULL}};
+static PyGetSetDef Nuitka_Method_tp_getset[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
+                                                {NULL}};
 
 #define OFF(x) offsetof(struct Nuitka_MethodObject, x)
 
@@ -58,20 +44,19 @@ static PyMemberDef Nuitka_Method_members[] = {
     {NULL}};
 
 static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method) {
-#if PYTHON_VERSION < 0x300
     PyThreadState *tstate = PyThreadState_GET();
 
+#if PYTHON_VERSION < 0x300
+    // spell-checker: ignore instancemethod
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle instancemethod objects");
     return NULL;
 #elif PYTHON_VERSION < 0x340
-    PyThreadState *tstate = PyThreadState_GET();
-
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle method objects");
     return NULL;
 #else
-    PyObject *result = MAKE_TUPLE_EMPTY(2);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 2);
     PyTuple_SET_ITEM0(result, 0, LOOKUP_BUILTIN(const_str_plain_getattr));
-    PyObject *arg_tuple = MAKE_TUPLE2(method->m_object, method->m_function->m_name);
+    PyObject *arg_tuple = MAKE_TUPLE2(tstate, method->m_object, method->m_function->m_name);
     PyTuple_SET_ITEM(result, 1, arg_tuple);
 
     CHECK_OBJECT_DEEP(result);
@@ -104,13 +89,13 @@ static PyObject *Nuitka_Method_reduce_ex(struct Nuitka_MethodObject *method, PyO
         return NULL;
     }
 
-    PyObject *result = MAKE_TUPLE_EMPTY(5);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 5);
     PyTuple_SET_ITEM(result, 0, newobj_func);
-    PyObject *type_tuple = MAKE_TUPLE1((PyObject *)&Nuitka_Method_Type);
+    PyObject *type_tuple = MAKE_TUPLE1(tstate, (PyObject *)&Nuitka_Method_Type);
     PyTuple_SET_ITEM(result, 1, type_tuple);
-    PyTuple_SET_ITEM0(result, 2, Py_None);
-    PyTuple_SET_ITEM0(result, 3, Py_None);
-    PyTuple_SET_ITEM0(result, 4, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 2, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 3, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 4, Py_None);
 
     CHECK_OBJECT_DEEP(result);
 
@@ -258,16 +243,17 @@ static PyObject *Nuitka_Method_tp_call(struct Nuitka_MethodObject *method, PyObj
     }
 }
 
-static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method, PyObject *object, PyObject *klass) {
+static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method, PyObject *object,
+                                            PyObject *class_object) {
     // Don't rebind already bound methods.
     if (method->m_object != NULL) {
         Py_INCREF(method);
         return (PyObject *)method;
     }
 
-    if (method->m_class != NULL && klass != NULL) {
+    if (method->m_class != NULL && class_object != NULL) {
         // Quick subclass test, bound methods remain the same if the class is a sub class
-        int result = PyObject_IsSubclass(klass, method->m_class);
+        int result = PyObject_IsSubclass(class_object, method->m_class);
 
         if (unlikely(result < 0)) {
             return NULL;
@@ -277,7 +263,7 @@ static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method,
         }
     }
 
-    return Nuitka_Method_New(method->m_function, object, klass);
+    return Nuitka_Method_New(method->m_function, object, class_object);
 }
 
 static PyObject *Nuitka_Method_tp_getattro(struct Nuitka_MethodObject *method, PyObject *name) {
@@ -292,6 +278,8 @@ static PyObject *Nuitka_Method_tp_getattro(struct Nuitka_MethodObject *method, P
         }
     }
 
+    // Delegate all other attributes to the underlying function.
+    // TODO: Could be a bit more direct here, and know this is generic lookup.
     return PyObject_GetAttr((PyObject *)method->m_function, name);
 }
 
@@ -334,13 +322,13 @@ static PyObject *Nuitka_Method_tp_repr(struct Nuitka_MethodObject *method) {
 #endif
 
 #if PYTHON_VERSION < 0x350
-        PyObject *result = Nuitka_String_FromFormat(
-            "<bound compiled_method %s.%s of %s>", GET_CLASS_NAME(method->m_class),
-            Nuitka_String_AsString(method->m_function->m_name), Nuitka_String_AsString_Unchecked(object_repr));
+        PyObject *result =
+            Nuitka_String_FromFormat("<bound compiled_method %s.%s of %s>", GET_CLASS_NAME(method->m_class),
+                                     Nuitka_String_AsString_Unchecked(method->m_function->m_name),
+                                     Nuitka_String_AsString_Unchecked(object_repr));
 #else
-        PyObject *result = PyUnicode_FromFormat("<bound compiled_method %s of %s>",
-                                                Nuitka_String_AsString(method->m_function->m_qualname),
-                                                Nuitka_String_AsString_Unchecked(object_repr));
+        PyObject *result =
+            PyUnicode_FromFormat("<bound compiled_method %U of %U>", method->m_function->m_qualname, object_repr);
 #endif
 
         Py_DECREF(object_repr);
@@ -410,7 +398,7 @@ static PyObject *Nuitka_Method_tp_richcompare(struct Nuitka_MethodObject *a, str
         result = BOOL_FROM(!b_res);
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -428,10 +416,9 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     // Save the current exception, if any, we must to not corrupt it.
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
-    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
 
     Nuitka_GC_UnTrack(method);
@@ -449,42 +436,57 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     releaseToFreeList(free_list_methods, method, MAX_METHOD_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
 }
 
 static PyObject *Nuitka_Method_tp_new(PyTypeObject *type, PyObject *args, PyObject *kw) {
     PyObject *func;
     PyObject *self;
-    PyObject *klass = NULL;
+    PyObject *class_object = NULL;
 
     if (!_PyArg_NoKeywords("compiled_method", kw)) {
         return NULL;
-    } else if (!PyArg_UnpackTuple(args, "compiled_method", 2, 3, &func, &self, &klass)) {
+    }
+
+    if (!PyArg_UnpackTuple(args, "compiled_method", 2, 3, &func, &self, &class_object)) {
         return NULL;
-    } else if (!PyCallable_Check(func)) {
+    }
+
+    CHECK_OBJECT(func);
+
+    if (!PyCallable_Check(func)) {
         PyThreadState *tstate = PyThreadState_GET();
 
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "first argument must be callable");
         return NULL;
-    } else {
-        if (self == Py_None) {
-            self = NULL;
-        }
+    }
 
-        if (self == NULL && klass == NULL) {
-            PyThreadState *tstate = PyThreadState_GET();
+    if (self == Py_None) {
+        self = NULL;
+    }
 
-            SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "unbound methods must have non-NULL im_class");
-            return NULL;
-        }
+    if (self == NULL && class_object == NULL) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "unbound methods must have non-NULL im_class");
+        return NULL;
     }
 
-    assert(Nuitka_Function_Check(func));
+    if (Nuitka_Method_Check(func)) {
+        return Nuitka_Method_New(((struct Nuitka_MethodObject *)func)->m_function, self, class_object);
+    }
+
+    if (Nuitka_Function_Check(func) == false) {
+        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT_NICE("Cannot create compiled_ method from type '%s'", func);
+        return NULL;
+    }
 
-    return Nuitka_Method_New((struct Nuitka_FunctionObject *)func, self, klass);
+    return Nuitka_Method_New((struct Nuitka_FunctionObject *)func, self, class_object);
 }
 
 PyTypeObject Nuitka_Method_Type = {
@@ -531,7 +533,7 @@ PyTypeObject Nuitka_Method_Type = {
     0,                                                // tp_iternext
     Nuitka_Method_methods,                            // tp_methods
     Nuitka_Method_members,                            // tp_members
-    Nuitka_Method_getsets,                            // tp_getset
+    Nuitka_Method_tp_getset,                          // tp_getset
     0,                                                // tp_base
     0,                                                // tp_dict
     (descrgetfunc)Nuitka_Method_tp_descr_get,         // tp_descr_get
@@ -549,7 +551,7 @@ PyTypeObject Nuitka_Method_Type = {
     0,                                                // tp_weaklist
     0,                                                // tp_del
     0                                                 // tp_version_tag
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     ,
     0 /* tp_finalizer */
 #endif
@@ -557,14 +559,9 @@ PyTypeObject Nuitka_Method_Type = {
 
 void _initCompiledMethodType(void) {
     Nuitka_PyType_Ready(&Nuitka_Method_Type, &PyMethod_Type, false, true, false, false, false);
-
-#ifdef _NUITKA_PLUGIN_DILL_ENABLED
-    // TODO: Move this to a __nuitka__ module maybe
-    PyObject_SetAttrString((PyObject *)builtin_module, "compiled_method", (PyObject *)&Nuitka_Method_Type);
-#endif
 }
 
-PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass) {
+PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *class_object) {
     struct Nuitka_MethodObject *result;
 
     CHECK_OBJECT((PyObject *)function);
@@ -584,8 +581,8 @@ PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *ob
 
     result->m_object = object;
     Py_XINCREF(object);
-    result->m_class = klass;
-    Py_XINCREF(klass);
+    result->m_class = class_object;
+    Py_XINCREF(class_object);
 
     result->m_weakrefs = NULL;
 
@@ -596,3 +593,18 @@ PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *ob
     Nuitka_GC_Track(result);
     return (PyObject *)result;
 }
+
+//     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.

nuitka/build/static_src/HelpersAllocator.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
+
 // For interacting with the Python GC unexposed details
 
 // This file is included from another C file, help IDEs to still parse it on
@@ -23,8 +8,44 @@
 #include "nuitka/prelude.h"
 #endif
 
+void *(*python_obj_malloc)(void *ctx, size_t size) = NULL;
+void *(*python_mem_malloc)(void *ctx, size_t size) = NULL;
+void *(*python_mem_calloc)(void *ctx, size_t nelem, size_t elsize) = NULL;
+
+#if defined(Py_DEBUG)
+void *python_obj_ctx = NULL;
+void *python_mem_ctx = NULL;
+#endif
+
+void initNuitkaAllocators(void) {
+    // PyMem_SetupDebugHooks();
+
+    PyMemAllocatorEx allocators;
+
+    PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators);
+
+#if defined(Py_DEBUG)
+    python_obj_ctx = allocators.ctx;
+#endif
+
+    python_obj_malloc = allocators.malloc;
+
+    PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators);
+
+#if defined(Py_DEBUG)
+    python_mem_ctx = allocators.ctx;
+#endif
+
+    python_mem_malloc = allocators.malloc;
+    python_mem_calloc = allocators.calloc;
+}
+
+#if PYTHON_VERSION >= 0x3b0
+
 typedef struct _gc_runtime_state GCState;
 
+#if PYTHON_VERSION < 0x3d0
+
 #define AS_GC(o) ((PyGC_Head *)(((char *)(o)) - sizeof(PyGC_Head)))
 #define FROM_GC(g) ((PyObject *)(((char *)(g)) + sizeof(PyGC_Head)))
 
@@ -61,8 +82,6 @@ static void Nuitka_invoke_gc_callback(PyThreadState *tstate, const char *phase,
     PyObject *info = NULL;
 
     if (PyList_GET_SIZE(gcstate->callbacks) != 0) {
-        assert(false);
-
         info =
             Py_BuildValue("{sisnsn}", "generation", generation, "collected", collected, "uncollectable", uncollectable);
 
@@ -611,8 +630,19 @@ static Py_ssize_t Nuitka_gc_collect_generations(PyThreadState *tstate) {
     return n;
 }
 
+#else
+
+static void Nuitka_Py_ScheduleGC(PyThreadState *tstate) {
+    if (!_Py_eval_breaker_bit_is_set(tstate, _PY_GC_SCHEDULED_BIT)) {
+        _Py_set_eval_breaker_bit(tstate, _PY_GC_SCHEDULED_BIT);
+    }
+}
+
+#endif
+
 // This is called during object creation and might trigger garbage collection
 void Nuitka_PyObject_GC_Link(PyObject *op) {
+#if PYTHON_VERSION < 0x3d0
     PyGC_Head *g = AS_GC(op);
 
     PyThreadState *tstate = _PyThreadState_GET();
@@ -629,4 +659,43 @@ void Nuitka_PyObject_GC_Link(PyObject *op) {
         Nuitka_gc_collect_generations(tstate);
         gcstate->collecting = 0;
     }
+#else
+    PyGC_Head *gc = _Py_AS_GC(op);
+
+    // gc must be correctly aligned
+    _PyObject_ASSERT(op, ((uintptr_t)gc & (sizeof(uintptr_t) - 1)) == 0);
+
+    // TODO: Have this passed.
+
+    PyThreadState *tstate = _PyThreadState_GET();
+    GCState *gcstate = &tstate->interp->gc;
+
+    gc->_gc_next = 0;
+    gc->_gc_prev = 0;
+
+    gcstate->young.count++;
+    gcstate->heap_size++;
+
+    if (gcstate->young.count > gcstate->young.threshold && gcstate->enabled && gcstate->young.threshold &&
+        !_Py_atomic_load_int_relaxed(&gcstate->collecting) && !_PyErr_Occurred(tstate)) {
+        Nuitka_Py_ScheduleGC(tstate);
+    }
+#endif
 }
+
+#endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersAttributes.c

@@ -1,20 +1,4 @@
-//     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
 
 // This file is included from another C file, help IDEs to still parse it on
 // its own.
@@ -22,25 +6,23 @@
 #include "nuitka/prelude.h"
 #endif
 
-// spell-checker: ignore klass
-
 #if PYTHON_VERSION < 0x300
-PyObject *FIND_ATTRIBUTE_IN_CLASS(PyClassObject *klass, PyObject *attr_name) {
-    CHECK_OBJECT(klass);
+PyObject *FIND_ATTRIBUTE_IN_CLASS(PyClassObject *class_object, PyObject *attr_name) {
+    CHECK_OBJECT(class_object);
     CHECK_OBJECT(attr_name);
 
-    assert(PyClass_Check(klass));
+    assert(PyClass_Check(class_object));
     assert(PyString_CheckExact(attr_name));
 
-    PyObject *result = GET_STRING_DICT_VALUE((PyDictObject *)klass->cl_dict, (PyStringObject *)attr_name);
+    PyObject *result = GET_STRING_DICT_VALUE((PyDictObject *)class_object->cl_dict, (PyStringObject *)attr_name);
 
     if (result == NULL) {
-        assert(PyTuple_Check(klass->cl_bases));
+        assert(PyTuple_Check(class_object->cl_bases));
 
-        Py_ssize_t base_count = PyTuple_GET_SIZE(klass->cl_bases);
+        Py_ssize_t base_count = PyTuple_GET_SIZE(class_object->cl_bases);
 
         for (Py_ssize_t i = 0; i < base_count; i++) {
-            result = FIND_ATTRIBUTE_IN_CLASS((PyClassObject *)PyTuple_GET_ITEM(klass->cl_bases, i), attr_name);
+            result = FIND_ATTRIBUTE_IN_CLASS((PyClassObject *)PyTuple_GET_ITEM(class_object->cl_bases, i), attr_name);
 
             if (result != NULL) {
                 break;
@@ -140,7 +122,7 @@ PyObject *LOOKUP_ATTRIBUTE(PyThreadState *tstate, PyObject *source, PyObject *at
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *result = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -292,7 +274,7 @@ PyObject *LOOKUP_ATTRIBUTE_DICT_SLOT(PyThreadState *tstate, PyObject *source) {
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *result = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -409,7 +391,7 @@ PyObject *LOOKUP_ATTRIBUTE_CLASS_SLOT(PyThreadState *tstate, PyObject *source) {
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *result = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -574,7 +556,7 @@ bool HAS_ATTR_BOOL(PyThreadState *tstate, PyObject *source, PyObject *attr_name)
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *result = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -743,7 +725,7 @@ int HAS_ATTR_BOOL2(PyThreadState *tstate, PyObject *source, PyObject *attr_name)
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *result = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -945,7 +927,7 @@ static bool SET_ATTRIBUTE_GENERIC(PyThreadState *tstate, PyTypeObject *type, PyO
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             descrsetfunc func = Py_TYPE(descr)->tp_descr_set;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 int res = func(descr, target, value);
                 Py_DECREF(descr);
 
@@ -991,7 +973,7 @@ static bool SET_ATTRIBUTE_GENERIC(PyThreadState *tstate, PyTypeObject *type, PyO
             dict = *dict_pointer;
 
             if (dict == NULL) {
-                dict = MAKE_DICT_EMPTY();
+                dict = MAKE_DICT_EMPTY(tstate);
                 *dict_pointer = dict;
             }
         }
@@ -1208,7 +1190,7 @@ PyObject *LOOKUP_SPECIAL(PyThreadState *tstate, PyObject *source, PyObject *attr
         }
     }
 
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
     SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_AttributeError, attr_name);
 #else
     // TODO: Maybe we should have dedicated variations with the 4 hard coded
@@ -1244,19 +1226,7 @@ PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK(PyThreadState *tstate, PyObject *va
     PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
 
     if (unlikely(result == NULL)) {
-        PyObject *exception_type;
-        PyObject *exception_value;
-
-        // TODO: Do this in one go, once FORMAT_NAME_ERROR becomes unused in code generation.
-        FORMAT_NAME_ERROR(&exception_type, &exception_value, variable_name);
-
-#if PYTHON_VERSION >= 0x300
-        // TODO: FORMAT_NAME_ERROR for Python3 should already produce this normalized and chained.
-        NORMALIZE_EXCEPTION(tstate, &exception_type, &exception_value, NULL);
-        CHAIN_EXCEPTION(tstate, exception_value);
-#endif
-
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, NULL);
+        SET_CURRENT_EXCEPTION_NAME_ERROR(tstate, variable_name);
     }
 
     return result;
@@ -1267,14 +1237,23 @@ PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(PyThreadState *tstate,
     PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
 
     if (unlikely(result == NULL)) {
-        PyObject *exception_type;
-        PyObject *exception_value;
-
-        FORMAT_GLOBAL_NAME_ERROR(&exception_type, &exception_value, variable_name);
-
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, NULL);
+        SET_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(tstate, variable_name);
     }
 
     return result;
 }
-#endif
+#endif
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.