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

nuitka/build/static_src/HelpersComparisonNe.c

@@ -2118,20 +2118,24 @@ static PyObject *COMPARE_NE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
         r = false;
     } else {
         int kind1 = PyUnicode_KIND(a);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind1 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
         }
+#endif
 
         int kind2 = PyUnicode_KIND(b);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind2 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
         }
+#endif
 
         if (kind1 != kind2) {
             r = false;
@@ -2781,20 +2785,24 @@ static bool COMPARE_NE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
         r = false;
     } else {
         int kind1 = PyUnicode_KIND(a);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind1 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
         }
+#endif
 
         int kind2 = PyUnicode_KIND(b);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind2 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
         }
+#endif
 
         if (kind1 != kind2) {
             r = false;
@@ -6213,13 +6221,15 @@ static PyObject *COMPARE_NE_OBJECT_LONG_LONG(PyObject *operand1, PyObject *opera
 
     if (operand1_long_object == operand2_long_object) {
         r = false;
-    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+    } else if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+               Nuitka_LongGetSignedDigitSize(operand2_long_object)) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] !=
+                Nuitka_LongGetDigitPointer(operand2_long_object)[i]) {
                 r = true;
                 break;
             }
@@ -6833,13 +6843,15 @@ static bool COMPARE_NE_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
 
     if (operand1_long_object == operand2_long_object) {
         r = false;
-    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+    } else if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+               Nuitka_LongGetSignedDigitSize(operand2_long_object)) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] !=
+                Nuitka_LongGetDigitPointer(operand2_long_object)[i]) {
                 r = true;
                 break;
             }
@@ -11697,13 +11709,13 @@ static PyObject *COMPARE_NE_OBJECT_LONG_CLONG(PyObject *operand1, long operand2)
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != operand2_size) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) != operand2_size) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != operand2_digits[i]) {
                 r = true;
                 break;
             }
@@ -11758,13 +11770,13 @@ static bool COMPARE_NE_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != operand2_size) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) != operand2_size) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != operand2_digits[i]) {
                 r = true;
                 break;
             }
@@ -11836,13 +11848,14 @@ static PyObject *COMPARE_NE_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2)
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+        (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != (digit)Py_ABS(operand2)) {
                 r = true;
                 break;
             }
@@ -11870,13 +11883,14 @@ static bool COMPARE_NE_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2) {
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+        (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
         r = true;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = false;
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != (digit)Py_ABS(operand2)) {
                 r = true;
                 break;
             }

nuitka/build/static_src/HelpersDeepcopy.c

@@ -361,10 +361,9 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
     } else if (PyLong_Check(value)) {
         Py_hash_t result = DEEP_HASH_INIT(tstate, value);
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         // Use string to hash the long value, which relies on that to not
         // use the object address.
@@ -372,16 +371,15 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
         result ^= DEEP_HASH(tstate, str);
         Py_DECREF(str);
 
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     } else if (PyUnicode_Check(value)) {
         Py_hash_t result = DEEP_HASH(tstate, (PyObject *)Py_TYPE(value));
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
 #if PYTHON_VERSION >= 0x300
         char const *s = (char const *)PyUnicode_DATA(value);
@@ -397,7 +395,7 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
 
         Py_DECREF(str);
 #endif
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     }

nuitka/build/static_src/HelpersDictionaries.c

@@ -199,7 +199,7 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
         SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_KeyError, key);
     }
 #else
-    PyObject *exception_value = _MAKE_EXCEPTION_FROM_TYPE_ARG0(PyExc_KeyError, key);
+    PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_KeyError, key);
 
     SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_KeyError, exception_value);
 #endif
@@ -1346,16 +1346,21 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
 PyObject *MAKE_DICT_EMPTY(void) {
     PyDictObject *empty_dict_mp = (PyDictObject *)const_dict_empty;
 
+#if PYTHON_VERSION < 0x3c0
     empty_dict_mp->ma_keys->dk_refcnt++;
+#endif
 
     PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
 
     result_mp->ma_keys = empty_dict_mp->ma_keys;
     result_mp->ma_values = empty_dict_mp->ma_values;
     result_mp->ma_used = 0;
+#if PYTHON_VERSION >= 0x3c0
+    result_mp->ma_version_tag = DICT_NEXT_VERSION(_PyInterpreterState_GET());
+#endif
 
-    // Key reference needs to be counted.
-#ifdef Py_REF_DEBUG
+    // Key reference needs to be counted on older Python
+#if defined(Py_REF_DEBUG) && PYTHON_VERSION < 0x3c0
     _Py_RefTotal++;
 #endif
 

nuitka/build/static_src/HelpersExceptions.c

@@ -42,26 +42,6 @@ void SET_CURRENT_EXCEPTION_TYPE_COMPLAINT_NICE(char const *format, PyObject *mis
     SET_CURRENT_EXCEPTION_TYPE0_FORMAT1(PyExc_TypeError, format, TYPE_NAME_DESC(mistyped));
 }
 
-void FORMAT_NAME_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_NameError;
-    Py_INCREF(*exception_type);
-
-    *exception_value =
-        Nuitka_String_FromFormat("name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
-}
-
-#if PYTHON_VERSION < 0x340
-void FORMAT_GLOBAL_NAME_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_NameError;
-    Py_INCREF(*exception_type);
-
-    *exception_value =
-        Nuitka_String_FromFormat("global name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
-}
-#endif
-
 void FORMAT_UNBOUND_LOCAL_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
     *exception_type = PyExc_UnboundLocalError;
     Py_INCREF(*exception_type);
@@ -114,7 +94,6 @@ static PyObject *_Nuitka_Err_CreateException(PyThreadState *tstate, PyObject *ex
     return exc;
 }
 
-#if PYTHON_VERSION < 0x3c0
 // Our replacement for PyErr_NormalizeException, that however does not attempt
 // to deal with recursion, i.e. exception during normalization, we just avoid
 // the API call overhead in the normal case.
@@ -128,20 +107,23 @@ void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObje
 
     // Allow setting the value to NULL for time savings with quick type only errors
     if (value == NULL) {
+        // TODO: For Python3.12, these kinds of assignments from immortal objects
+        // should be specialized, might need to check Python source for how they
+        // do that.
         value = Py_None;
         Py_INCREF(value);
     }
 
     // Normalize the exception from class to instance
     if (PyExceptionClass_Check(type)) {
-        PyObject *inclass = NULL;
+        PyObject *instance_class = NULL;
 
         int is_subclass = 0;
 
         if (PyExceptionInstance_Check(value)) {
-            inclass = PyExceptionInstance_Class(value);
+            instance_class = PyExceptionInstance_Class(value);
 
-            is_subclass = PyObject_IsSubclass(inclass, type);
+            is_subclass = PyObject_IsSubclass(instance_class, type);
 
             if (is_subclass < 0) {
                 goto error;
@@ -159,12 +141,12 @@ void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObje
 
             Py_DECREF(value);
             value = fixed_value;
-        } else if (inclass != type) {
+        } else if (instance_class != type) {
             // Switch to given type then
-            Py_INCREF(inclass);
+            Py_INCREF(instance_class);
             Py_DECREF(type);
 
-            type = inclass;
+            type = instance_class;
         }
     }
 
@@ -179,7 +161,11 @@ error:
     Py_DECREF(value);
     PyTracebackObject *initial_tb = *tb;
 
-    FETCH_ERROR_OCCURRED(tstate, exc, val, tb);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
+
+    ASSIGN_ARGS_FROM_EXCEPTION_PRESERVATION_STATE(&exception_state, exc, val, tb);
+    RELEASE_ERROR_OCCURRED_STATE(&exception_state);
 
     if (initial_tb != NULL) {
         if (*tb == NULL) {
@@ -195,7 +181,35 @@ error:
     PyErr_NormalizeException(exc, val, (PyObject **)tb);
 #endif
 }
+
+// Raise NameError for a given variable name.
+void SET_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name) {
+    PyObject *exception_value_str =
+        Nuitka_String_FromFormat("name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
+
+    PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
+    Py_DECREF(exception_value_str);
+
+#if PYTHON_VERSION >= 0x300
+    CHAIN_EXCEPTION(tstate, exception_value);
 #endif
+
+    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_NameError, exception_value);
+}
+
+// Raise NameError with "global" for a given variable name.
+#if PYTHON_VERSION < 0x340
+void SET_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name) {
+    PyObject *exception_value_str =
+        Nuitka_String_FromFormat("global name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
+
+    PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
+    Py_DECREF(exception_value_str);
+
+    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_NameError, exception_value);
+}
+#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/HelpersFilesystemPaths.c

@@ -446,15 +446,15 @@ uint32_t getFileCRC32(filename_char_t const *filename) {
 
 #ifdef _WIN32
 
-static DWORD Nuitka_GetFinalPathNameByHandleW(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags) {
-    typedef DWORD(WINAPI * pfnGetFinalPathNameByHandleW)(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath,
+static DWORD Nuitka_GetFinalPathNameByHandleW(HANDLE hFile, LPWSTR FilePath, DWORD cchFilePath, DWORD dwFlags) {
+    typedef DWORD(WINAPI * pfnGetFinalPathNameByHandleW)(HANDLE hFile, LPWSTR FilePath, DWORD cchFilePath,
                                                          DWORD dwFlags);
 
     pfnGetFinalPathNameByHandleW fnGetFinalPathNameByHandleW =
         (pfnGetFinalPathNameByHandleW)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "GetFinalPathNameByHandleW");
 
     if (fnGetFinalPathNameByHandleW != NULL) {
-        return fnGetFinalPathNameByHandleW(hFile, lpszFilePath, cchFilePath, dwFlags);
+        return fnGetFinalPathNameByHandleW(hFile, FilePath, cchFilePath, dwFlags);
     } else {
         // There are no symlinks before Windows Vista.
         return 0;
@@ -683,6 +683,8 @@ static bool appendStringCSIDLPathW(wchar_t *target, int csidl_id, size_t buffer_
         return false;
     }
 #else
+    // spell-checker: ignore USERPROFILE,LOCALAPPDATA
+
     DWORD res = 0;
     if (csidl_id == CSIDL_PROFILE) {
         res = GetEnvironmentVariableW(L"USERPROFILE", path_buffer, sizeof(path_buffer));
@@ -777,6 +779,7 @@ bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_s
             } else if (wcsicmp(var_name, L"TIME") == 0) {
                 char time_buffer[1024];
 
+                // spell-checker: ignore LPFILETIME
                 __int64 time = 0;
                 assert(sizeof(time) == sizeof(FILETIME));
                 GetSystemTimeAsFileTime((LPFILETIME)&time);
@@ -905,12 +908,9 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
                 if (xdg_cache_home != NULL && xdg_cache_home[0] == '/') {
                     appendStringSafe(target, xdg_cache_home, buffer_size);
                 } else {
-                    if (expandTemplatePath(target, "{HOME}", buffer_size - strlen(target)) == false) {
+                    if (expandTemplatePath(target, "{HOME}/.cache", buffer_size - strlen(target)) == false) {
                         return false;
                     }
-
-                    appendCharSafe(target, '/', buffer_size);
-                    appendStringSafe(target, ".cache", buffer_size);
                 }
                 is_path = true;
 #ifdef NUITKA_COMPANY_NAME

nuitka/build/static_src/HelpersImportHard.c

@@ -438,6 +438,21 @@ PyObject *IMPORT_HARD_SYSCONFIG(void) {
     return module_import_hard_sysconfig;
 }
 
+/* C helper for hard import of module "tensorflow" import. */
+PyObject *IMPORT_HARD_TENSORFLOW(void) {
+    static PyObject *module_import_hard_tensorflow = NULL;
+
+    if (module_import_hard_tensorflow == NULL) {
+        module_import_hard_tensorflow = PyImport_ImportModule("tensorflow");
+
+        if (unlikely(module_import_hard_tensorflow == NULL)) {
+            return NULL;
+        }
+    }
+
+    return module_import_hard_tensorflow;
+}
+
 /* C helper for hard import of module "types" import. */
 PyObject *IMPORT_HARD_TYPES(void) {
     static PyObject *module_import_hard_types = NULL;

nuitka/build/static_src/HelpersJitSources.c

@@ -0,0 +1,46 @@
+//     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.
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+#ifdef _NUITKA_STANDALONE
+
+static char const *uncompiled_sources_dict_attribute_name = "_uncompiled_function_sources_dict";
+
+void SET_UNCOMPILED_FUNCTION_SOURCE_DICT(PyObject *name, PyObject *source) {
+    PyObject *uncompiled_function_sources_dict =
+        PyObject_GetAttrString((PyObject *)builtin_module, uncompiled_sources_dict_attribute_name);
+
+    if (uncompiled_function_sources_dict == NULL) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        DROP_ERROR_OCCURRED(tstate);
+
+        uncompiled_function_sources_dict = MAKE_DICT_EMPTY();
+
+        PyObject_SetAttrString((PyObject *)builtin_module, uncompiled_sources_dict_attribute_name,
+                               uncompiled_function_sources_dict);
+    }
+
+    bool res = DICT_SET_ITEM(uncompiled_function_sources_dict, name, source);
+    assert(res == false);
+}
+
+#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/HelpersLists.c

@@ -372,6 +372,46 @@ bool LIST_APPEND0(PyObject *target, PyObject *item) {
 #endif
 }
 
+bool LIST_REMOVE(PyObject *target, PyObject *item) {
+    CHECK_OBJECT(target);
+    assert(PyList_CheckExact(target));
+
+    CHECK_OBJECT(item);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+    int res = PyList_Remove(target, item);
+    return res == 0;
+#else
+    PyListObject *list = (PyListObject *)target;
+
+    Py_ssize_t cur_size = PyList_GET_SIZE(list);
+
+    for (Py_ssize_t i = 0; i < cur_size; i++) {
+        PyObject *element = list->ob_item[i];
+
+        Py_INCREF(element);
+        nuitka_bool cmp = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(element, item);
+        Py_DECREF(element);
+
+        if (cmp == NUITKA_BOOL_TRUE) {
+            Py_DECREF(element);
+            Py_SET_SIZE(list, cur_size - 1);
+
+            memmove(list->ob_item + i, list->ob_item + i + 1, sizeof(PyObject *) * (cur_size - i - 1));
+
+            return true;
+        } else if (unlikely(cmp == NUITKA_BOOL_EXCEPTION)) {
+            return false;
+        }
+    }
+
+    PyThreadState *tstate = PyThreadState_GET();
+
+    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "list.remove(x): x not in list");
+    return false;
+#endif
+}
+
 void LIST_CLEAR(PyObject *target) {
     CHECK_OBJECT(target);
     assert(PyList_CheckExact(target));