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

nuitka/build/static_src/CompiledMethodType.c

@@ -15,7 +15,8 @@
 #include <structmember.h>
 #endif
 
-static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, void *closure) {
+static PyObject *Nuitka_Method_get__doc__(PyObject *self, void *data) {
+    struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)self;
     PyObject *result = method->m_function->m_doc;
 
     if (result == NULL) {
@@ -26,8 +27,7 @@ static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, vo
     return result;
 }
 
-static PyGetSetDef Nuitka_Method_tp_getset[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
-                                                {NULL}};
+static PyGetSetDef Nuitka_Method_tp_getset[] = {{(char *)"__doc__", Nuitka_Method_get__doc__, NULL, NULL}, {NULL}};
 
 #define OFF(x) offsetof(struct Nuitka_MethodObject, x)
 
@@ -43,16 +43,13 @@ static PyMemberDef Nuitka_Method_members[] = {
      (char *)"the instance to which a method is bound; None for unbound method"},
     {NULL}};
 
-static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method) {
+static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method, PyObject *unused) {
     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
-    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle method objects");
-    return NULL;
 #else
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, 2);
     PyTuple_SET_ITEM0(result, 0, LOOKUP_BUILTIN(const_str_plain_getattr));
@@ -74,12 +71,9 @@ static PyObject *Nuitka_Method_reduce_ex(struct Nuitka_MethodObject *method, PyO
 
     // Python API, spell-checker: ignore copyreg,newobj
 
-#if PYTHON_VERSION < 0x340
 #if PYTHON_VERSION < 0x300
     PyObject *copy_reg = PyImport_ImportModule("copy_reg");
-#else
-    PyObject *copy_reg = PyImport_ImportModule("copyreg");
-#endif
+
     CHECK_OBJECT(copy_reg);
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -101,7 +95,7 @@ static PyObject *Nuitka_Method_reduce_ex(struct Nuitka_MethodObject *method, PyO
 
     return result;
 #else
-    return Nuitka_Method_reduce(method);
+    return Nuitka_Method_reduce(method, NULL);
 #endif
 }
 
@@ -125,7 +119,10 @@ static PyObject *Nuitka_Method_deepcopy(struct Nuitka_MethodObject *method, PyOb
         return NULL;
     }
 
-    return Nuitka_Method_New(method->m_function, object, method->m_class);
+    PyObject *result = Nuitka_Method_New(method->m_function, object, method->m_class);
+    // Nuitka_Method_New took a reference to the object.
+    Py_DECREF(object);
+    return result;
 }
 
 static PyMethodDef Nuitka_Method_methods[] = {

nuitka/build/static_src/HelpersAllocator.c

@@ -8,9 +8,18 @@
 #include "nuitka/prelude.h"
 #endif
 
+// spell-checker: ignore PYMEM_DOMAIN,Nuitka_gc_decref,gcstate,uncollectable,sisnsn,QSBR,wrasgc
+// spell-checker: ignore Nuitka_visit_decref,finalizers,wrcb,wrlist,_PyObject_GET_WEAKREFS_LISTPTR
+// spell-checker: ignore objmalloc,qbsr,stoptheworld
+
 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;
+#ifndef Py_GIL_DISABLED
+void *(*python_mem_realloc)(void *ctx, void *ptr, size_t new_size) = NULL;
+#else
+void (*python_mem_free)(void *ctx, void *ptr) = NULL;
+#endif
 
 #if defined(Py_DEBUG)
 void *python_obj_ctx = NULL;
@@ -18,8 +27,6 @@ void *python_mem_ctx = NULL;
 #endif
 
 void initNuitkaAllocators(void) {
-    // PyMem_SetupDebugHooks();
-
     PyMemAllocatorEx allocators;
 
     PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators);
@@ -38,6 +45,11 @@ void initNuitkaAllocators(void) {
 
     python_mem_malloc = allocators.malloc;
     python_mem_calloc = allocators.calloc;
+#ifndef Py_GIL_DISABLED
+    python_mem_realloc = allocators.realloc;
+#else
+    python_mem_free = allocators.free;
+#endif
 }
 
 #if PYTHON_VERSION >= 0x3b0
@@ -306,7 +318,7 @@ static void Nuitka_gc_list_move(PyGC_Head *node, PyGC_Head *list) {
     _PyGCHead_SET_NEXT(node, list);
 }
 
-static void Nuitka_move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers) {
+static void _Nuitka_move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers) {
     PyGC_Head *next;
     for (PyGC_Head *gc = GC_NEXT(unreachable); gc != unreachable; gc = next) {
         PyObject *op = FROM_GC(gc);
@@ -322,11 +334,11 @@ static void Nuitka_move_legacy_finalizers(PyGC_Head *unreachable, PyGC_Head *fin
     }
 }
 
-static int Nuitka_visit_move(PyObject *op, PyGC_Head *tolist) {
+static int _Nuitka_visit_move(PyObject *op, PyGC_Head *to_list) {
     if (_PyObject_IS_GC(op)) {
         PyGC_Head *gc = AS_GC(op);
         if (Nuitka_gc_is_collecting(gc)) {
-            Nuitka_gc_list_move(gc, tolist);
+            Nuitka_gc_list_move(gc, to_list);
             Nuitka_gc_clear_collecting(gc);
         }
     }
@@ -338,7 +350,7 @@ static int Nuitka_visit_move(PyObject *op, PyGC_Head *tolist) {
 static void Nuitka_move_legacy_finalizer_reachable(PyGC_Head *finalizers) {
     for (PyGC_Head *gc = GC_NEXT(finalizers); gc != finalizers; gc = GC_NEXT(gc)) {
         traverseproc traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
-        (void)traverse(FROM_GC(gc), (visitproc)Nuitka_visit_move, (void *)finalizers);
+        (void)traverse(FROM_GC(gc), (visitproc)_Nuitka_visit_move, (void *)finalizers);
     }
 }
 
@@ -350,15 +362,15 @@ static void Nuitka_finalize_garbage(PyThreadState *tstate, PyGC_Head *collectabl
 
     while (Nuitka_gc_list_is_empty(collectable) == false) {
         PyGC_Head *gc = GC_NEXT(collectable);
-        PyObject *op = FROM_GC(gc);
+        PyObject *object = FROM_GC(gc);
         Nuitka_gc_list_move(gc, &seen);
 
-        if (!_PyGCHead_FINALIZED(gc) && (finalize = Py_TYPE(op)->tp_finalize) != NULL) {
+        if (!_PyGCHead_FINALIZED(gc) && (finalize = Py_TYPE(object)->tp_finalize) != NULL) {
             _PyGCHead_SET_FINALIZED(gc);
-            Py_INCREF(op);
-            finalize(op);
+            Py_INCREF(object);
+            finalize(object);
             assert(!HAS_ERROR_OCCURRED(tstate));
-            Py_DECREF(op);
+            Py_DECREF(object);
         }
     }
     Nuitka_gc_list_merge(&seen, collectable);
@@ -366,7 +378,7 @@ static void Nuitka_finalize_garbage(PyThreadState *tstate, PyGC_Head *collectabl
 
 static int Nuitka_handle_weakrefs(PyThreadState *tstate, PyGC_Head *unreachable, PyGC_Head *old) {
     PyGC_Head *gc;
-    PyObject *op;
+    PyObject *object;
     PyWeakReference *wr;
     PyGC_Head wrcb_to_call;
     PyGC_Head *next;
@@ -377,17 +389,17 @@ static int Nuitka_handle_weakrefs(PyThreadState *tstate, PyGC_Head *unreachable,
     for (gc = GC_NEXT(unreachable); gc != unreachable; gc = next) {
         PyWeakReference **wrlist;
 
-        op = FROM_GC(gc);
+        object = FROM_GC(gc);
         next = GC_NEXT(gc);
 
-        if (PyWeakref_Check(op)) {
-            _PyWeakref_ClearRef((PyWeakReference *)op);
+        if (PyWeakref_Check(object)) {
+            _PyWeakref_ClearRef((PyWeakReference *)object);
         }
 
-        if (!_PyType_SUPPORTS_WEAKREFS(Py_TYPE(op)))
+        if (!_PyType_SUPPORTS_WEAKREFS(Py_TYPE(object)))
             continue;
 
-        wrlist = (PyWeakReference **)_PyObject_GET_WEAKREFS_LISTPTR(op);
+        wrlist = (PyWeakReference **)_PyObject_GET_WEAKREFS_LISTPTR(object);
 
         for (wr = *wrlist; wr != NULL; wr = *wrlist) {
             PyGC_Head *wrasgc;
@@ -414,8 +426,8 @@ static int Nuitka_handle_weakrefs(PyThreadState *tstate, PyGC_Head *unreachable,
         PyObject *callback;
 
         gc = (PyGC_Head *)wrcb_to_call._gc_next;
-        op = FROM_GC(gc);
-        wr = (PyWeakReference *)op;
+        object = FROM_GC(gc);
+        wr = (PyWeakReference *)object;
         callback = wr->wr_callback;
 
         temp = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, callback, (PyObject *)wr);
@@ -424,7 +436,7 @@ static int Nuitka_handle_weakrefs(PyThreadState *tstate, PyGC_Head *unreachable,
         else
             Py_DECREF(temp);
 
-        Py_DECREF(op);
+        Py_DECREF(object);
         if (wrcb_to_call._gc_next == (uintptr_t)gc) {
             Nuitka_gc_list_move(gc, old);
         } else {
@@ -466,19 +478,19 @@ static void Nuitka_delete_garbage(PyThreadState *tstate, GCState *gcstate, PyGC_
 
     while (Nuitka_gc_list_is_empty(collectable) == false) {
         PyGC_Head *gc = GC_NEXT(collectable);
-        PyObject *op = FROM_GC(gc);
+        PyObject *object = FROM_GC(gc);
 
-        _PyObject_ASSERT_WITH_MSG(op, Py_REFCNT(op) > 0, "refcount is too small");
+        _PyObject_ASSERT_WITH_MSG(object, Py_REFCNT(object) > 0, "refcount is too small");
 
         {
             inquiry clear;
-            if ((clear = Py_TYPE(op)->tp_clear) != NULL) {
-                Py_INCREF(op);
-                (void)clear(op);
+            if ((clear = Py_TYPE(object)->tp_clear) != NULL) {
+                Py_INCREF(object);
+                (void)clear(object);
                 if (HAS_ERROR_OCCURRED(tstate)) {
-                    _PyErr_WriteUnraisableMsg("in tp_clear of", (PyObject *)Py_TYPE(op));
+                    _PyErr_WriteUnraisableMsg("in tp_clear of", (PyObject *)Py_TYPE(object));
                 }
-                Py_DECREF(op);
+                Py_DECREF(object);
             }
         }
         if (GC_NEXT(collectable) == gc) {
@@ -560,7 +572,7 @@ static Py_ssize_t Nuitka_gc_collect_main(PyThreadState *tstate, int generation,
 
     Nuitka_gc_list_init(&finalizers);
 
-    Nuitka_move_legacy_finalizers(&unreachable, &finalizers);
+    _Nuitka_move_legacy_finalizers(&unreachable, &finalizers);
 
     Nuitka_move_legacy_finalizer_reachable(&finalizers);
 
@@ -673,11 +685,11 @@ void Nuitka_PyObject_GC_Link(PyObject *op) {
     gc->_gc_next = 0;
     gc->_gc_prev = 0;
 
-    gcstate->young.count++;
-    gcstate->heap_size++;
+    gcstate->generations[0].count++;
 
-    if (gcstate->young.count > gcstate->young.threshold && gcstate->enabled && gcstate->young.threshold &&
-        !_Py_atomic_load_int_relaxed(&gcstate->collecting) && !_PyErr_Occurred(tstate)) {
+    if (gcstate->generations[0].count > gcstate->generations[0].threshold && gcstate->enabled &&
+        gcstate->generations[0].threshold && !_Py_atomic_load_int_relaxed(&gcstate->collecting) &&
+        !_PyErr_Occurred(tstate)) {
         Nuitka_Py_ScheduleGC(tstate);
     }
 #endif
@@ -685,6 +697,232 @@ void Nuitka_PyObject_GC_Link(PyObject *op) {
 
 #endif
 
+#ifdef Py_GIL_DISABLED
+
+// Needs to align with CPython "objmalloc.c"
+#define WORK_ITEMS_PER_CHUNK 254
+struct _mem_work_item {
+    uintptr_t ptr; // lowest bit tagged 1 for objects freed with PyObject_Free
+    uint64_t qsbr_goal;
+};
+
+struct _mem_work_chunk {
+    struct llist_node node;
+
+    Py_ssize_t rd_idx; // index of next item to read
+    Py_ssize_t wr_idx; // index of next item to write
+    struct _mem_work_item array[WORK_ITEMS_PER_CHUNK];
+};
+
+// Aligns with CPython "qsbr.c"
+#define QSBR_DEFERRED_LIMIT 10
+
+static uint64_t Nuitka_qsbr_advance(struct _qsbr_shared *shared) {
+    return _Py_atomic_add_uint64(&shared->wr_seq, QSBR_INCR) + QSBR_INCR;
+}
+
+static uint64_t Nuitka_qsbr_deferred_advance(struct _qsbr_thread_state *qsbr) {
+    if (++qsbr->deferrals < QSBR_DEFERRED_LIMIT) {
+        return _Py_qsbr_shared_current(qsbr->shared) + QSBR_INCR;
+    }
+    qsbr->deferrals = 0;
+    return Nuitka_qsbr_advance(qsbr->shared);
+}
+
+static uint64_t _Nuitka_qsbr_poll_scan(struct _qsbr_shared *shared) {
+    _Py_atomic_fence_seq_cst();
+
+    uint64_t min_seq = _Py_atomic_load_uint64(&shared->wr_seq);
+    struct _qsbr_pad *array = shared->array;
+    for (Py_ssize_t i = 0, size = shared->size; i != size; i++) {
+        struct _qsbr_thread_state *qsbr = &array[i].qsbr;
+
+        uint64_t seq = _Py_atomic_load_uint64(&qsbr->seq);
+        if (seq != QSBR_OFFLINE && QSBR_LT(seq, min_seq)) {
+            min_seq = seq;
+        }
+    }
+
+    uint64_t rd_seq = _Py_atomic_load_uint64(&shared->rd_seq);
+    if (QSBR_LT(rd_seq, min_seq)) {
+        (void)_Py_atomic_compare_exchange_uint64(&shared->rd_seq, &rd_seq, min_seq);
+        rd_seq = min_seq;
+    }
+
+    return rd_seq;
+}
+
+static bool _Nuitka_qsbr_poll(struct _qsbr_thread_state *qsbr, uint64_t goal) {
+    assert(_Py_atomic_load_int_relaxed(&_PyThreadState_GET()->state) == _Py_THREAD_ATTACHED);
+
+    if (_Py_qbsr_goal_reached(qsbr, goal)) {
+        return true;
+    }
+
+    uint64_t rd_seq = _Nuitka_qsbr_poll_scan(qsbr->shared);
+    return QSBR_LEQ(goal, rd_seq);
+}
+
+static void _NuitkaMem_free_work_item(uintptr_t ptr) {
+    if (ptr & 0x01) {
+        PyObject_Free((char *)(ptr - 1));
+    } else {
+        NuitkaMem_Free((void *)ptr);
+    }
+}
+
+static struct _mem_work_chunk *work_queue_first(struct llist_node *head) {
+    return llist_data(head->next, struct _mem_work_chunk, node);
+}
+
+static void _Nuitka_process_queue(struct llist_node *head, struct _qsbr_thread_state *qsbr, bool keep_empty) {
+    while (!llist_empty(head)) {
+        struct _mem_work_chunk *buf = work_queue_first(head);
+
+        while (buf->rd_idx < buf->wr_idx) {
+            struct _mem_work_item *item = &buf->array[buf->rd_idx];
+            if (!_Nuitka_qsbr_poll(qsbr, item->qsbr_goal)) {
+                return;
+            }
+
+            _NuitkaMem_free_work_item(item->ptr);
+            buf->rd_idx++;
+        }
+
+        assert(buf->rd_idx == buf->wr_idx);
+
+        if (keep_empty && buf->node.next == head) {
+            // Keeping the last buffer as a free-list entry.
+            buf->rd_idx = buf->wr_idx = 0;
+            return;
+        }
+
+        llist_remove(&buf->node);
+        NuitkaMem_Free(buf);
+    }
+}
+
+struct mutex_entry {
+    // The time after which the unlocking thread should hand off lock ownership
+    // directly to the waiting thread. Written by the waiting thread.
+    PyTime_t time_to_be_fair;
+
+    // Set to 1 if the lock was handed off. Written by the unlocking thread.
+    int handed_off;
+};
+
+static const PyTime_t TIME_TO_BE_FAIR_NS = 1000 * 1000;
+static const int MAX_SPIN_COUNT = 40;
+
+static void _Nuitka_yield(void) {
+#ifdef _WIN32
+    SwitchToThread();
+#else
+    sched_yield();
+#endif
+}
+
+PyLockStatus _NuitkaMutex_LockTimed(PyMutex *m) {
+    uint8_t v = _Py_atomic_load_uint8_relaxed(&m->_bits);
+    if ((v & _Py_LOCKED) == 0) {
+        if (_Py_atomic_compare_exchange_uint8(&m->_bits, &v, v | _Py_LOCKED)) {
+            return PY_LOCK_ACQUIRED;
+        }
+    } else {
+        return PY_LOCK_FAILURE;
+    }
+
+    Py_ssize_t spin_count = 0;
+
+    for (;;) {
+        if ((v & _Py_LOCKED) == 0) {
+            if (_Py_atomic_compare_exchange_uint8(&m->_bits, &v, v | _Py_LOCKED)) {
+                return PY_LOCK_ACQUIRED;
+            }
+            continue;
+        }
+
+        if (!(v & _Py_HAS_PARKED) && spin_count < MAX_SPIN_COUNT) {
+            // Spin for a bit.
+            _Nuitka_yield();
+
+            spin_count++;
+            continue;
+        }
+
+        return PY_LOCK_FAILURE;
+    }
+}
+
+static void _Nuitka_process_interp_queue(struct _Py_mem_interp_free_queue *queue, struct _qsbr_thread_state *qsbr) {
+    if (!_Py_atomic_load_int_relaxed(&queue->has_work)) {
+        return;
+    }
+
+    // Try to acquire the lock, but don't block if it's already held.
+    if (_NuitkaMutex_LockTimed(&queue->mutex) == PY_LOCK_ACQUIRED) {
+        _Nuitka_process_queue(&queue->head, qsbr, false);
+
+        int more_work = !llist_empty(&queue->head);
+        _Py_atomic_store_int_relaxed(&queue->has_work, more_work);
+
+        PyMutex_Unlock(&queue->mutex);
+    }
+}
+
+void _NuitkaMem_ProcessDelayed(PyThreadState *tstate) {
+    PyInterpreterState *interp = tstate->interp;
+    _PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate;
+
+    // Release thread-local queue
+    _Nuitka_process_queue(&tstate_impl->mem_free_queue, tstate_impl->qsbr, true);
+
+    // Release interpreter queue
+    _Nuitka_process_interp_queue(&interp->mem_free_queue, tstate_impl->qsbr);
+}
+
+static void _NuitkaMem_FreeDelayed2(uintptr_t ptr) {
+    // Free immediately if possible.
+    if (_PyRuntime.stoptheworld.world_stopped) {
+        _NuitkaMem_free_work_item(ptr);
+        return;
+    }
+
+    // Allocate an entry for later processing.
+    _PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET();
+    struct llist_node *head = &tstate->mem_free_queue;
+
+    struct _mem_work_chunk *buf = NULL;
+    if (!llist_empty(head)) {
+        // Try to reuse the last buffer
+        buf = llist_data(head->prev, struct _mem_work_chunk, node);
+        if (buf->wr_idx == WORK_ITEMS_PER_CHUNK) {
+            // already full
+            buf = NULL;
+        }
+    }
+
+    if (buf == NULL) {
+        buf = NuitkaMem_Calloc(1, sizeof(*buf));
+    }
+
+    assert(buf != NULL && buf->wr_idx < WORK_ITEMS_PER_CHUNK);
+    uint64_t seq = Nuitka_qsbr_deferred_advance(tstate->qsbr);
+    buf->array[buf->wr_idx].ptr = ptr;
+    buf->array[buf->wr_idx].qsbr_goal = seq;
+    buf->wr_idx++;
+
+    if (buf->wr_idx == WORK_ITEMS_PER_CHUNK) {
+        _NuitkaMem_ProcessDelayed((PyThreadState *)tstate);
+    }
+}
+
+void NuitkaMem_FreeDelayed(void *ptr) {
+    assert(!((uintptr_t)ptr & 0x01));
+    _NuitkaMem_FreeDelayed2((uintptr_t)ptr);
+}
+
+#endif
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //

nuitka/build/static_src/HelpersAttributes.c

@@ -1222,27 +1222,6 @@ PyObject *LOOKUP_MODULE_VALUE(PyDictObject *module_dict, PyObject *var_name) {
     return result;
 }
 
-PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK(PyThreadState *tstate, PyObject *variable_name) {
-    PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
-
-    if (unlikely(result == NULL)) {
-        SET_CURRENT_EXCEPTION_NAME_ERROR(tstate, variable_name);
-    }
-
-    return result;
-}
-
-#if PYTHON_VERSION < 0x340
-PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(PyThreadState *tstate, PyObject *variable_name) {
-    PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
-
-    if (unlikely(result == NULL)) {
-        SET_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(tstate, variable_name);
-    }
-
-    return result;
-}
-#endif
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //

nuitka/build/static_src/HelpersBuiltin.c

@@ -16,10 +16,10 @@
 #endif
 
 PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObject **args, char const **arg_names,
-                               int max_args) {
+                               int max_args, int kw_only_args) {
     int i = 0;
 
-    while (i < max_args) {
+    while (i < max_args - kw_only_args) {
         if (args[i] == NULL) {
             break;
         }
@@ -225,7 +225,7 @@ PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mod
 
     char const *arg_names[] = {"name", "mode", "buffering"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 3);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 3, 0);
 }
 #else
 PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mode, PyObject *buffering,
@@ -242,7 +242,7 @@ PyObject *BUILTIN_OPEN(PyThreadState *tstate, PyObject *file_name, PyObject *mod
 
     char const *arg_names[] = {"file", "mode", "buffering", "encoding", "errors", "newline", "closefd", "opener"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 8);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(open), args, arg_names, 8, 0);
 }
 
 #endif
@@ -315,7 +315,7 @@ PyObject *BUILTIN_BYTES3(PyThreadState *tstate, PyObject *value, PyObject *encod
 
     char const *arg_names[] = {"value", "encoding", "errors"};
 
-    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(bytes), args, arg_names, 3);
+    return CALL_BUILTIN_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(bytes), args, arg_names, 3, 0);
 }
 #endif
 
@@ -422,6 +422,7 @@ PyObject *BUILTIN_HEX(PyThreadState *tstate, PyObject *value) {
 
 static void SET_HASH_NOT_IMPLEMENTED_ERROR(PyThreadState *tstate, PyObject *value) {
     // TODO: Use our own formatting code.
+    // spell-checker: ignore unhashable
 
     PyErr_Format(PyExc_TypeError, "unhashable type: '%s'", Py_TYPE(value)->tp_name);
 }
@@ -450,8 +451,9 @@ PyObject *BUILTIN_HASH(PyThreadState *tstate, PyObject *value) {
         }
 
 #if PYTHON_VERSION < 0x300
-        return PyInt_FromLong(hash);
+        return Nuitka_PyInt_FromLong(hash);
 #else
+        // TODO: Have a dedicated helper of ours for this as well.
         return PyLong_FromSsize_t(hash);
 #endif
     }
@@ -459,7 +461,7 @@ PyObject *BUILTIN_HASH(PyThreadState *tstate, PyObject *value) {
 #if PYTHON_VERSION < 0x300
     if (likely(type->tp_compare == NULL && TP_RICHCOMPARE(type) == NULL)) {
         Py_hash_t hash = Nuitka_HashFromPointer(value);
-        return PyInt_FromLong(hash);
+        return Nuitka_PyInt_FromLong(hash);
     }
 #endif
 
@@ -553,7 +555,7 @@ PyObject *BUILTIN_BYTEARRAY3(PyThreadState *tstate, PyObject *string, PyObject *
  * This comes in two flavors, with one or two arguments. The second one
  * creates a "calliterobject" that is private to CPython. We define it here
  * for ourselves. The one argument version is in headers for in-lining of
- * the code.
+ * the code. spell-checker: ignore calliterobject
  *
  **/
 
@@ -720,13 +722,18 @@ PyObject *BUILTIN_GETATTR(PyThreadState *tstate, PyObject *object, PyObject *att
     PyObject *result = PyObject_GetAttr(object, attribute);
 
     if (result == NULL) {
-        if (default_value != NULL &&
-            EXCEPTION_MATCH_BOOL_SINGLE(tstate, GET_ERROR_OCCURRED(tstate), PyExc_AttributeError)) {
-            CLEAR_ERROR_OCCURRED(tstate);
+        if (default_value != NULL) {
+            if (HAS_ERROR_OCCURRED(tstate)) {
+                if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, GET_ERROR_OCCURRED(tstate), PyExc_AttributeError)) {
+                    CLEAR_ERROR_OCCURRED(tstate);
+                }
+            }
 
             Py_INCREF(default_value);
             return default_value;
         } else {
+            assert(HAS_ERROR_OCCURRED(tstate));
+
             return NULL;
         }
     } else {
@@ -750,7 +757,7 @@ PyObject *BUILTIN_SETATTR(PyObject *object, PyObject *attribute, PyObject *value
 }
 
 PyObject *BUILTIN_INT2(PyThreadState *tstate, PyObject *value, PyObject *base) {
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
     long base_int = PyInt_AsLong(base);
 #else
     Py_ssize_t base_int = PyNumber_AsSsize_t(base, NULL);
@@ -759,7 +766,9 @@ PyObject *BUILTIN_INT2(PyThreadState *tstate, PyObject *value, PyObject *base) {
     if (unlikely(base_int == -1)) {
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
-        if (likely(error)) {
+        if (likely(error != NULL)) {
+            assert(HAS_ERROR_OCCURRED(tstate));
+
 #if PYTHON_VERSION >= 0x300
             if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_OverflowError)) {
                 PyErr_Format(PyExc_ValueError,

nuitka/build/static_src/HelpersCalling.c

@@ -148,8 +148,8 @@ static PyObject *callPythonFunctionNoArgs(PyObject *func) {
 
 #endif
 
-PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
-                                   PyObject *positional_args) {
+PyObject *CALL_METHOD_WITH_POS_ARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                    PyObject *positional_args) {
     CHECK_OBJECT(source);
     CHECK_OBJECT(attr_name);
     CHECK_OBJECT(positional_args);
@@ -170,7 +170,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
         // Note: The "called_object" was found without taking a reference,
         // so we need not release it in this branch.
         if (called_object != NULL) {
-            return CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+            return CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
         }
         // Then check the class dictionaries.
         called_object = FIND_ATTRIBUTE_IN_CLASS(source_instance->in_class, attr_name);
@@ -191,11 +191,11 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
                     return NULL;
                 }
 
-                PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, method, positional_args);
+                PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, method, positional_args);
                 Py_DECREF(method);
                 return result;
             } else {
-                return CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+                return CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
             }
         } else if (unlikely(source_instance->in_class->cl_getattr == NULL)) {
             PyErr_Format(PyExc_AttributeError, "%s instance has no attribute '%s'",
@@ -214,7 +214,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
                 return NULL;
             }
 
-            PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+            PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
             Py_DECREF(called_object);
             return result;
         }
@@ -240,7 +240,7 @@ PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyOb
             return NULL;
         }
 
-        PyObject *result = CALL_FUNCTION_WITH_POSARGS(tstate, called_object, positional_args);
+        PyObject *result = CALL_FUNCTION_WITH_POS_ARGS(tstate, called_object, positional_args);
         Py_DECREF(called_object);
         return result;
     }