Nuitka-winsvc 2.3.9__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersDictionaries.c

@@ -574,6 +574,15 @@ int DICT_HAS_ITEM(PyThreadState *tstate, PyObject *dict, PyObject *key) {
 
         return 0;
     }
+
+#if PYTHON_VERSION < 0x370 || PYTHON_VERSION >= 0x3b0
+    assert(value_addr != NULL);
+    PyObject *result = *value_addr;
+#endif
+
+    if (unlikely(result == NULL)) {
+        return 0;
+    }
 #endif
     return 1;
 #endif

nuitka/build/static_src/HelpersFiles.c

@@ -10,7 +10,7 @@
 
 // Small helper to open files with few arguments.
 PyObject *BUILTIN_OPEN_SIMPLE(PyThreadState *tstate, PyObject *filename, char const *mode, bool buffering,
-                              PyObject *encoding) {
+                              PyObject *encoding, bool close_fd) {
     PyObject *mode_obj = Nuitka_String_FromString(mode);
     PyObject *buffering_obj = buffering ? const_int_pos_1 : const_int_0;
 
@@ -38,7 +38,7 @@ PyObject *BUILTIN_OPEN_SIMPLE(PyThreadState *tstate, PyObject *filename, char co
         PyObject *mode_obj2 = PyUnicode_FromString("wb");
 
         PyObject *binary_stream =
-            BUILTIN_OPEN(tstate, filename, mode_obj2, buffering_obj, NULL, NULL, NULL, NULL, NULL);
+            BUILTIN_OPEN(tstate, filename, mode_obj2, buffering_obj, NULL, NULL, NULL, BOOL_FROM(close_fd), NULL);
 
         Py_DECREF(mode_obj2);
 

nuitka/build/static_src/HelpersFilesystemPaths.c

@@ -18,7 +18,9 @@
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <libgen.h>
+#if !defined(__wasi__)
 #include <pwd.h>
+#endif
 #include <stdlib.h>
 #include <strings.h>
 #include <sys/mman.h>
@@ -35,7 +37,7 @@
 #include "nuitka/safe_string_ops.h"
 
 #if defined(__OpenBSD__)
-void _getBinaryPath2(char *epath) {
+void _getBinaryPath2(char *binary_filename) {
     int mib[4];
     mib[0] = CTL_KERN;
     mib[1] = KERN_PROC_ARGS;
@@ -60,7 +62,7 @@ void _getBinaryPath2(char *epath) {
     const char *comm = argv[0];
 
     if (*comm == '/' || *comm == '.') {
-        if (realpath(comm, epath) == NULL) {
+        if (realpath(comm, binary_filename) == NULL) {
             abort();
         }
     } else {
@@ -74,9 +76,9 @@ void _getBinaryPath2(char *epath) {
         }
 
         while (path) {
-            snprintf(epath, PATH_MAX, "%s/%s", path, comm);
+            snprintf(binary_filename, PATH_MAX, "%s/%s", path, comm);
 
-            if (!stat(epath, &st) && (st.st_mode & S_IXUSR)) {
+            if (!stat(binary_filename, &st) && (st.st_mode & S_IXUSR)) {
                 break;
             }
 
@@ -225,7 +227,7 @@ int64_t getFileSize(FILE_HANDLE file_handle) {
 #if defined(__APPLE__)
 #include <copyfile.h>
 #else
-#if defined(__MSYS__) || defined(__HAIKU__) || defined(__OpenBSD__)
+#if defined(__MSYS__) || defined(__HAIKU__) || defined(__OpenBSD__) || defined(__wasi__)
 static bool sendfile(int output_file, int input_file, off_t *bytesCopied, size_t count) {
     char buffer[32768];
 
@@ -435,6 +437,7 @@ static struct MapFileToMemoryInfo mapFileToMemory(filename_char_t const *filenam
         result.error = true;
         result.error_code = errno;
         result.erroring_function = "open";
+        result.file_size = -1;
         return result;
     }
 
@@ -573,6 +576,9 @@ static void resolveFileSymbolicLink(wchar_t *resolved_filename, wchar_t const *f
 
 static void resolveFileSymbolicLink(char *resolved_filename, char const *filename, size_t resolved_filename_size,
                                     bool resolve_symlinks) {
+#ifdef __wasi__
+    copyStringSafe(resolved_filename, filename, resolved_filename_size);
+#else
     if (resolve_symlinks) {
         // At least on macOS, realpath cannot allocate a buffer, itself, so lets
         // use a local one, only on Linux we could use NULL argument and have a
@@ -589,24 +595,27 @@ static void resolveFileSymbolicLink(char *resolved_filename, char const *filenam
     } else {
         copyStringSafe(resolved_filename, filename, resolved_filename_size);
     }
+#endif
 }
 #endif
 
 #ifdef _WIN32
 wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks) {
-    static wchar_t binary_filename[MAXPATHLEN + 1];
-    static bool init_done = false;
+    static wchar_t binary_filename[MAXPATHLEN + 1] = {0};
+    static wchar_t binary_filename_resolved[MAXPATHLEN + 1] = {0};
 
-    if (init_done == false) {
-        DWORD res = GetModuleFileNameW(NULL, binary_filename, sizeof(binary_filename) / sizeof(wchar_t));
+    wchar_t *buffer = resolve_symlinks ? binary_filename : binary_filename_resolved;
+    assert(sizeof(binary_filename) == sizeof(binary_filename_resolved));
+
+    if (buffer[0] == 0) {
+        DWORD res = GetModuleFileNameW(NULL, buffer, sizeof(binary_filename) / sizeof(wchar_t));
         assert(res != 0);
 
         // Resolve any symlinks we were invoked via
-        resolveFileSymbolicLink(binary_filename, binary_filename, sizeof(binary_filename) / sizeof(wchar_t),
-                                resolve_symlinks);
+        resolveFileSymbolicLink(buffer, buffer, sizeof(binary_filename) / sizeof(wchar_t), resolve_symlinks);
     }
 
-    return binary_filename;
+    return buffer;
 }
 #endif
 
@@ -675,6 +684,9 @@ char const *getBinaryFilenameHostEncoded(bool resolve_symlinks) {
 
     // Resolve any symlinks we were invoked via
     resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
+#elif defined(__wasi__)
+    const char *wasi_filename = "program.wasm";
+    strncpy(binary_filename_resolved, wasi_filename, MAXPATHLEN);
 #elif defined(__OpenBSD__)
     _getBinaryPath2(binary_filename_target);
     resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
@@ -949,8 +961,10 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
                 appendStringSafe(target, pid_buffer, buffer_size);
             } else if (strcasecmp(var_name, "HOME") == 0) {
                 char const *home_path = getenv("HOME");
-
                 if (home_path == NULL) {
+#ifdef __wasi__
+                    return false;
+#else
                     struct passwd *pw_data = getpwuid(getuid());
 
                     if (unlikely(pw_data == NULL)) {
@@ -958,6 +972,7 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
                     }
 
                     home_path = pw_data->pw_dir;
+#endif
                 }
 
                 appendStringSafe(target, home_path, buffer_size);

nuitka/build/static_src/HelpersHeapStorage.c

@@ -28,6 +28,8 @@ void Nuitka_PreserveHeap(void *dest, ...) {
         memcpy(w, source, size);
         w += size;
     }
+
+    va_end(ap);
 }
 
 void Nuitka_RestoreHeap(void *source, ...) {
@@ -46,6 +48,8 @@ void Nuitka_RestoreHeap(void *source, ...) {
         memcpy(dest, w, size);
         w += size;
     }
+
+    va_end(ap);
 }
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/static_src/HelpersImport.c

@@ -236,7 +236,7 @@ PyObject *IMPORT_NAME_FROM_MODULE(PyThreadState *tstate, PyObject *module, PyObj
             Py_DECREF(filename);
             Py_DECREF(name);
 
-#elif PYTHON_VERSION >= 0x340 || !defined(_NUITKA_FULL_COMPAT)
+#elif PYTHON_VERSION >= 0x300 || !defined(_NUITKA_FULL_COMPAT)
             PyErr_Format(PyExc_ImportError, "cannot import name '%s'", Nuitka_String_AsString(import_name));
 #else
             PyErr_Format(PyExc_ImportError, "cannot import name %s", Nuitka_String_AsString(import_name));

nuitka/build/static_src/HelpersLists.c

@@ -227,7 +227,7 @@ bool LIST_EXTEND_FROM_ITERABLE(PyThreadState *tstate, PyObject *target, PyObject
 
     Py_ssize_t cur_size = PyList_GET_SIZE(list);
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     // Guess a iterator size if possible
     src_size = PyObject_LengthHint(other, 8);
 
@@ -757,6 +757,8 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
         return list;
     }
 #else
+    Py_INCREF(iterable);
+
 #if PYTHON_VERSION >= 0x340
     if (Nuitka_PyObject_HasLen(iterable)) {
         Py_ssize_t iter_len = Nuitka_PyObject_Size(iterable);
@@ -779,6 +781,8 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
 
     bool res = LIST_EXTEND_FROM_ITERABLE(tstate, list, iterable);
 
+    Py_DECREF(iterable);
+
     if (unlikely(res == false)) {
         Py_DECREF(list);
         return NULL;

nuitka/build/static_src/HelpersMatching.c

@@ -18,46 +18,59 @@ static void FORMAT_MATCH_MISMATCH_ERROR(PyTypeObject *type, Py_ssize_t max_allow
                  ((PyTypeObject *)type)->tp_name, max_allowed, plural_form, actual);
 }
 
-PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t max_allowed) {
+PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, PyObject *matched_type,
+                           Py_ssize_t positional_count, PyObject **keywords, Py_ssize_t keywords_count) {
     PyObject *match_args = NULL;
-    PyTypeObject *type = Py_TYPE(matched);
+    PyTypeObject *type = (PyTypeObject *)matched_type;
 
-    // First, the positional sub-patterns:
-    match_args = LOOKUP_ATTRIBUTE(tstate, (PyObject *)type, const_str_plain___match_args__);
-    Py_ssize_t actual;
+    PyObject *seen = NULL;
+    bool needs_check = positional_count + keywords_count > 1;
+    if (needs_check) {
+        seen = PySet_New(NULL);
+    }
 
-    if (match_args) {
-        if (unlikely(!PyTuple_CheckExact(match_args))) {
-            PyErr_Format(PyExc_TypeError, "%s.__match_args__ must be a tuple (got %s)", type->tp_name,
-                         Py_TYPE(match_args)->tp_name);
-            Py_DECREF(match_args);
-            return NULL;
-        }
+    assert(positional_count + keywords_count > 0);
+
+    // First, the positional sub-patterns if any.
+    if (positional_count > 0) {
+        match_args = LOOKUP_ATTRIBUTE(tstate, (PyObject *)type, const_str_plain___match_args__);
+        Py_ssize_t actual;
 
-        actual = PyTuple_GET_SIZE(match_args);
-    } else if (CHECK_AND_CLEAR_ATTRIBUTE_ERROR_OCCURRED(tstate)) {
-        if (PyType_HasFeature(type, _Py_TPFLAGS_MATCH_SELF)) {
-            if (max_allowed > 1) {
-                FORMAT_MATCH_MISMATCH_ERROR(type, max_allowed, 1);
+        if (match_args) {
+            if (unlikely(!PyTuple_CheckExact(match_args))) {
+                PyErr_Format(PyExc_TypeError, "%s.__match_args__ must be a tuple (got %s)", type->tp_name,
+                             Py_TYPE(match_args)->tp_name);
+                Py_DECREF(match_args);
                 return NULL;
             }
 
-            return MAKE_TUPLE1(tstate, matched);
-        }
+            actual = PyTuple_GET_SIZE(match_args);
+        } else if (CHECK_AND_CLEAR_ATTRIBUTE_ERROR_OCCURRED(tstate)) {
+            if (PyType_HasFeature(type, _Py_TPFLAGS_MATCH_SELF)) {
+                if (positional_count > 1) {
+                    FORMAT_MATCH_MISMATCH_ERROR(type, positional_count, 1);
+                    return NULL;
+                }
 
-        actual = 0;
-    } else {
-        return NULL;
-    }
+                assert(keywords_count == 0);
+
+                return MAKE_TUPLE1(tstate, matched);
+            }
+
+            actual = 0;
+        } else {
+            return NULL;
+        }
 
-    if (max_allowed > actual) {
-        FORMAT_MATCH_MISMATCH_ERROR(type, max_allowed, actual);
-        return NULL;
+        if (positional_count > actual) {
+            FORMAT_MATCH_MISMATCH_ERROR(type, positional_count, actual);
+            return NULL;
+        }
     }
 
-    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, actual);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, positional_count + keywords_count);
 
-    for (Py_ssize_t i = 0; i < max_allowed; i++) {
+    for (Py_ssize_t i = 0; i < positional_count; i++) {
         PyObject *arg_name = PyTuple_GET_ITEM(match_args, i);
 
         if (unlikely(!PyUnicode_CheckExact(arg_name))) {
@@ -72,27 +85,74 @@ PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t
             return NULL;
         }
 
+        if (needs_check) {
+            if (i != 0 && PySet_Contains(seen, arg_name)) {
+                _PyErr_Format(tstate, PyExc_TypeError, "%s() got multiple sub-patterns for attribute %R",
+                              ((PyTypeObject *)type)->tp_name, arg_name);
+
+                return NULL;
+            }
+
+            PySet_Add(seen, arg_name);
+        }
+
         PyObject *arg_value = LOOKUP_ATTRIBUTE(tstate, matched, arg_name);
         if (unlikely(arg_value == NULL)) {
+            DROP_ERROR_OCCURRED(tstate);
+
             Py_DECREF(match_args);
             Py_DECREF(result);
 
-            return NULL;
+            Py_INCREF_IMMORTAL(Py_None);
+            return Py_None;
         }
 
         PyTuple_SET_ITEM(result, i, arg_value);
     }
 
-    Py_DECREF(match_args);
+    for (Py_ssize_t i = 0; i < keywords_count; i++) {
+        PyObject *arg_name = keywords[i];
+        CHECK_OBJECT(arg_name);
+        assert(PyUnicode_CheckExact(arg_name));
+
+        if (needs_check) {
+            if (PySet_Contains(seen, arg_name)) {
+                _PyErr_Format(tstate, PyExc_TypeError, "%s() got multiple sub-patterns for attribute %R",
+                              ((PyTypeObject *)type)->tp_name, arg_name);
+
+                return NULL;
+            }
+
+            PySet_Add(seen, arg_name);
+        }
+
+        PyObject *arg_value = LOOKUP_ATTRIBUTE(tstate, matched, arg_name);
+        if (unlikely(arg_value == NULL)) {
+            DROP_ERROR_OCCURRED(tstate);
+
+            Py_DECREF(match_args);
+            Py_DECREF(result);
+
+            Py_INCREF_IMMORTAL(Py_None);
+            return Py_None;
+        }
+
+        PyTuple_SET_ITEM(result, positional_count + i, arg_value);
+    }
+
+    Py_XDECREF(match_args);
     return result;
 }
 
-int MATCH_MAPPING_KEY(PyThreadState *tstate, PyObject *map, PyObject *key) {
+bool MATCH_MAPPING_KEY(PyThreadState *tstate, PyObject *map, PyObject *key) {
     // Need to use get_method with default value, so "defaultdict" do not
     // mutate. TODO: Use a cached value across the "match".
+    // spell-checker: ignore defaultdict
     PyObject *get_method = LOOKUP_ATTRIBUTE(tstate, map, const_str_plain_get);
     if (unlikely(get_method == NULL)) {
-        return -1;
+        // TODO: Maybe only drop AttributeError?
+        DROP_ERROR_OCCURRED(tstate);
+        return false;
     }
 
     PyObject *args[] = {key, Nuitka_sentinel_value};
@@ -102,18 +162,18 @@ int MATCH_MAPPING_KEY(PyThreadState *tstate, PyObject *map, PyObject *key) {
     Py_XDECREF(get_method);
 
     if (unlikely(value == NULL)) {
-        return -1;
+        return false;
     }
 
     if (value == Nuitka_sentinel_value) {
         Py_DECREF_IMMORTAL(value);
 
-        return 0;
+        return false;
     }
 
     Py_DECREF(value);
 
-    return 1;
+    return true;
 }
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/static_src/HelpersOperationInplaceAdd.c

@@ -245,7 +245,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_INT(PyObject **op
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'int'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'int'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -497,7 +497,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_INT_OBJECT(PyObject **op
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'int' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'int' and '%s'", type2->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -881,9 +881,9 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_LONG(PyObject **o
         }
 
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'long'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'long'", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'int'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'int'", type1->tp_name);
 #endif
         goto exit_inplace_exception;
     }
@@ -1180,9 +1180,9 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_LONG_OBJECT(PyObject **o
         }
 
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'long' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'long' and '%s'", type2->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'int' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'int' and '%s'", type2->tp_name);
 #endif
         goto exit_inplace_exception;
     }
@@ -1540,7 +1540,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_FLOAT(PyObject **
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'float'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'float'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -1765,7 +1765,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_FLOAT_OBJECT(PyObject **
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'float' and '%s'", type2->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'float' and '%s'", type2->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -1889,9 +1889,9 @@ static inline bool _INPLACE_OPERATION_ADD_FLOAT_LONG(PyObject **operand1, PyObje
         }
 
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'float' and 'long'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'float' and 'long'");
 #else
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'float' and 'int'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'float' and 'int'");
 #endif
         goto exit_inplace_exception;
     }
@@ -1968,9 +1968,9 @@ static inline bool _INPLACE_OPERATION_ADD_LONG_FLOAT(PyObject **operand1, PyObje
         }
 
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'long' and 'float'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'long' and 'float'");
 #else
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'int' and 'float'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'int' and 'float'");
 #endif
         goto exit_inplace_exception;
     }
@@ -2041,7 +2041,7 @@ static inline bool _INPLACE_OPERATION_ADD_FLOAT_INT(PyObject **operand1, PyObjec
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'float' and 'int'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'float' and 'int'");
         goto exit_inplace_exception;
     }
 
@@ -2118,7 +2118,7 @@ static inline bool _INPLACE_OPERATION_ADD_INT_FLOAT(PyObject **operand1, PyObjec
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'int' and 'float'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'int' and 'float'");
         goto exit_inplace_exception;
     }
 
@@ -2189,7 +2189,7 @@ static inline bool _INPLACE_OPERATION_ADD_LONG_INT(PyObject **operand1, PyObject
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'long' and 'int'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'long' and 'int'");
         goto exit_inplace_exception;
     }
 
@@ -2266,7 +2266,7 @@ static inline bool _INPLACE_OPERATION_ADD_INT_LONG(PyObject **operand1, PyObject
             // No inplace sequence repeat slot sq_inplace_concat available for this type.
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: 'int' and 'long'");
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: 'int' and 'long'");
         goto exit_inplace_exception;
     }
 
@@ -2703,7 +2703,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_STR(PyObject **op
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'str'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -3096,9 +3096,9 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_UNICODE(PyObject
         }
 
 #if PYTHON_VERSION < 0x300
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'unicode'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'unicode'", type1->tp_name);
 #else
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'str'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'str'", type1->tp_name);
 #endif
         goto exit_inplace_exception;
     }
@@ -3497,7 +3497,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_BYTES(PyObject **
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'bytes'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'bytes'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -3890,7 +3890,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_TUPLE(PyObject **
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'tuple'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'tuple'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -4282,7 +4282,7 @@ static HEDLEY_NEVER_INLINE bool __INPLACE_OPERATION_ADD_OBJECT_LIST(PyObject **o
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and 'list'", type1->tp_name);
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and 'list'", type1->tp_name);
         goto exit_inplace_exception;
     }
 
@@ -4945,7 +4945,7 @@ static inline bool _INPLACE_OPERATION_ADD_OBJECT_OBJECT(PyObject **operand1, PyO
             }
         }
 
-        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +: '%s' and '%s'", type1->tp_name,
+        PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for +=: '%s' and '%s'", type1->tp_name,
                      type2->tp_name);
         goto exit_inplace_exception;
     }

nuitka/build/static_src/HelpersOperationInplaceAddUtils.c

@@ -75,6 +75,7 @@ NUITKA_MAY_BE_UNUSED static bool BYTES_ADD_INCREMENTAL(PyObject **operand1, PyOb
         // Has to work.
         assert(res == 0);
     }
+    assert(wb.len >= 0);
 
     Py_ssize_t oldsize = PyBytes_GET_SIZE(*operand1);