Nuitka-winsvc 2.1.5__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersOperationInplaceSub.c

@@ -607,8 +607,8 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_LONG(PyObject **operand1, PyObjec
 
     PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object);
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object));
 
         if (Py_REFCNT(*operand1) == 1) {
             Nuitka_LongUpdateFromCLong(&*operand1, r);
@@ -624,18 +624,18 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_LONG(PyObject **operand1, PyObjec
     }
 
     if (Py_REFCNT(*operand1) == 1) {
-        digit const *b_digits = operand2_long_object->ob_digit;
-        Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
+        digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+        Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
 
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
-        bool b_negative = Py_SIZE(operand2_long_object) < 0;
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+        bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
         if (a_negative) {
             if (b_negative) {
                 *operand1 = _Nuitka_LongSubInplaceDigits(*operand1, b_digits, b_digit_count, -1);
             } else {
                 *operand1 = _Nuitka_LongAddInplaceDigits(*operand1, b_digits, b_digit_count);
-                Py_SET_SIZE(*operand1, -Py_ABS(Py_SIZE(*operand1)));
+                Nuitka_LongSetSignNegative(*operand1);
             }
         } else {
             if (b_negative) {
@@ -650,12 +650,12 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_LONG(PyObject **operand1, PyObjec
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
-        digit const *b_digits = operand2_long_object->ob_digit;
-        Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-        bool b_negative = Py_SIZE(operand2_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+        digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+        Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+        bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
         if (a_negative) {
             if (b_negative) {
@@ -664,7 +664,7 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_LONG(PyObject **operand1, PyObjec
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
             }
 
-            Py_SET_SIZE(z, -(Py_SIZE(z)));
+            Nuitka_LongFlipSign(z);
         } else {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
@@ -898,8 +898,8 @@ static inline bool _INPLACE_OPERATION_SUB_OBJECT_LONG(PyObject **operand1, PyObj
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object));
 
             if (Py_REFCNT(*operand1) == 1) {
                 Nuitka_LongUpdateFromCLong(&*operand1, r);
@@ -915,18 +915,18 @@ static inline bool _INPLACE_OPERATION_SUB_OBJECT_LONG(PyObject **operand1, PyObj
         }
 
         if (Py_REFCNT(*operand1) == 1) {
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
 
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     *operand1 = _Nuitka_LongSubInplaceDigits(*operand1, b_digits, b_digit_count, -1);
                 } else {
                     *operand1 = _Nuitka_LongAddInplaceDigits(*operand1, b_digits, b_digit_count);
-                    Py_SET_SIZE(*operand1, -Py_ABS(Py_SIZE(*operand1)));
+                    Nuitka_LongSetSignNegative(*operand1);
                 }
             } else {
                 if (b_negative) {
@@ -941,12 +941,12 @@ static inline bool _INPLACE_OPERATION_SUB_OBJECT_LONG(PyObject **operand1, PyObj
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
@@ -955,7 +955,7 @@ static inline bool _INPLACE_OPERATION_SUB_OBJECT_LONG(PyObject **operand1, PyObj
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
                 }
 
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
@@ -1194,8 +1194,8 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_OBJECT(PyObject **operand1, PyObj
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) - MEDIUM_VALUE(operand2_long_object));
 
             if (Py_REFCNT(*operand1) == 1) {
                 Nuitka_LongUpdateFromCLong(&*operand1, r);
@@ -1211,18 +1211,18 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_OBJECT(PyObject **operand1, PyObj
         }
 
         if (Py_REFCNT(*operand1) == 1) {
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
 
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     *operand1 = _Nuitka_LongSubInplaceDigits(*operand1, b_digits, b_digit_count, -1);
                 } else {
                     *operand1 = _Nuitka_LongAddInplaceDigits(*operand1, b_digits, b_digit_count);
-                    Py_SET_SIZE(*operand1, -Py_ABS(Py_SIZE(*operand1)));
+                    Nuitka_LongSetSignNegative(*operand1);
                 }
             } else {
                 if (b_negative) {
@@ -1237,12 +1237,12 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_OBJECT(PyObject **operand1, PyObj
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
@@ -1251,7 +1251,7 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_OBJECT(PyObject **operand1, PyObj
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
                 }
 
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
@@ -2308,8 +2308,8 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long o
 
     PyLongObject *operand1_long_object = (PyLongObject *)*operand1;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) - (sdigit)operand2;
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) - (sdigit)operand2);
 
         if (Py_REFCNT(*operand1) == 1) {
             Nuitka_LongUpdateFromCLong(&*operand1, r);
@@ -2328,7 +2328,7 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long o
         digit const *b_digits = (digit *)&operand2;
         Py_ssize_t b_digit_count = (operand2 == 0 ? 0 : 1);
 
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
         bool b_negative = operand2 < 0;
 
         if (a_negative) {
@@ -2336,7 +2336,7 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long o
                 *operand1 = _Nuitka_LongSubInplaceDigits(*operand1, b_digits, b_digit_count, -1);
             } else {
                 *operand1 = _Nuitka_LongAddInplaceDigits(*operand1, b_digits, b_digit_count);
-                Py_SET_SIZE(*operand1, -Py_ABS(Py_SIZE(*operand1)));
+                Nuitka_LongSetSignNegative(*operand1);
             }
         } else {
             if (b_negative) {
@@ -2351,9 +2351,9 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long o
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
         digit const *b_digits = (digit *)&operand2;
         Py_ssize_t b_digit_count = (operand2 == 0 ? 0 : 1);
         bool b_negative = operand2 < 0;
@@ -2365,7 +2365,7 @@ static inline bool _INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long o
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
             }
 
-            Py_SET_SIZE(z, -(Py_SIZE(z)));
+            Nuitka_LongFlipSign(z);
         } else {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);

nuitka/build/static_src/HelpersProfiling.c

@@ -63,9 +63,8 @@ void stopProfiling(void) {
     // Save the current exception, if any, we must preserve 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);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     PyObject *result = CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(vmprof_module, "disable"));
 
@@ -84,7 +83,7 @@ void stopProfiling(void) {
 
     fclose(tempfile_times);
 
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
 #endif

nuitka/build/static_src/HelpersRaising.c

@@ -56,7 +56,10 @@ void RAISE_EXCEPTION_WITH_TYPE(PyThreadState *tstate, PyObject **exception_type,
     if (PyExceptionClass_Check(*exception_type)) {
         NORMALIZE_EXCEPTION(tstate, exception_type, exception_value, exception_tb);
 #if PYTHON_VERSION >= 0x270
+        // TODO: It seems NORMALIZE_EXCEPTION already does this?
         if (unlikely(!PyExceptionInstance_Check(*exception_value))) {
+            assert(false);
+
             PyObject *old_exception_type = *exception_type;
             PyObject *old_exception_value = *exception_value;
 
@@ -122,7 +125,12 @@ void RAISE_EXCEPTION_WITH_CAUSE(PyThreadState *tstate, PyObject **exception_type
             Py_DECREF(*exception_type);
             Py_XDECREF(*exception_tb);
 
-            FETCH_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+            struct Nuitka_ExceptionPreservationItem exception_state;
+            FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
+
+            ASSIGN_ARGS_FROM_EXCEPTION_PRESERVATION_STATE(&exception_state, exception_type, exception_value,
+                                                          exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(&exception_state);
 
             return;
         }
@@ -420,6 +428,59 @@ bool RERAISE_EXCEPTION(PyObject **exception_type, PyObject **exception_value, Py
     return true;
 }
 
+// Raise NameError for a given variable name.
+void RAISE_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name, PyObject **exception_type,
+                                        PyObject **exception_value) {
+    PyObject *exception_value_str =
+        Nuitka_String_FromFormat("name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
+
+    *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
+    Py_DECREF(exception_value_str);
+
+    *exception_type = PyExc_NameError;
+    Py_INCREF(PyExc_NameError);
+
+#if PYTHON_VERSION >= 0x300
+    CHAIN_EXCEPTION(tstate, *exception_value);
+#endif
+}
+
+#if PYTHON_VERSION < 0x340
+void RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name,
+                                               PyObject **exception_type, PyObject **exception_value) {
+    PyObject *exception_value_str =
+        Nuitka_String_FromFormat("global name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
+
+    *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
+    Py_DECREF(exception_value_str);
+
+    *exception_type = PyExc_NameError;
+    Py_INCREF(PyExc_NameError);
+}
+#endif
+
+#if PYTHON_VERSION >= 0x300
+
+void RAISE_EXCEPTION_WITH_CAUSE_STATE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state,
+                                      PyObject *exception_cause) {
+#if PYTHON_VERSION < 0x3c0
+    RAISE_EXCEPTION_WITH_CAUSE(tstate, &exception_state->exception_type, &exception_state->exception_value,
+                               &exception_state->exception_tb, exception_cause);
+#else
+    PyObject *exception_type = (PyObject *)PyExceptionInstance_Class(exception_state->exception_value);
+    Py_INCREF(exception_type);
+    PyTracebackObject *exception_tb = NULL;
+
+    // Python3.12: We are being a bit lazy there, by preparing the 3 things when
+    // we shouldn't really need them.
+    RAISE_EXCEPTION_WITH_CAUSE(tstate, &exception_type, &exception_state->exception_value, &exception_tb,
+                               exception_cause);
+
+    Py_DECREF(exception_type);
+#endif
+}
+#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/HelpersStrings.c

@@ -140,8 +140,10 @@ PyObject *BUILTIN_ORD(PyObject *value) {
 #define _PyUnicode_KIND(op) (((PyASCIIObject *)(op))->state.kind)
 #define _PyUnicode_DATA_ANY(op) (((PyUnicodeObject *)(op))->data.any)
 
+#if PYTHON_VERSION < 0x3c0
 #undef PyUnicode_READY
 #define PyUnicode_READY(op) ((PyUnicode_IS_READY(op) ? 0 : _PyUnicode_Ready(op)))
+#endif
 
 #define _PyUnicode_SHARE_UTF8(op) (assert(!PyUnicode_IS_COMPACT_ASCII(op)), (_PyUnicode_UTF8(op) == PyUnicode_DATA(op)))
 #define _PyUnicode_SHARE_WSTR(op) ((_PyUnicode_WSTR(unicode) == PyUnicode_DATA(op)))
@@ -232,6 +234,7 @@ static int _NuitkaUnicode_modifiable(PyObject *unicode) {
     return 1;
 }
 
+#if PYTHON_VERSION < 0x3c0
 static PyObject *_NuitkaUnicode_New(Py_ssize_t length) {
     assert(length != 0);
 
@@ -294,6 +297,24 @@ static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length
     }
 }
 
+#else
+
+static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length) {
+    // TODO: We should inline this one as well, it's doable and would save a bunch
+    // for the copying case as well.
+    PyObject *copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
+
+    if (unlikely(copy == NULL)) {
+        return NULL;
+    }
+
+    Py_ssize_t copy_length = Py_MIN(length, PyUnicode_GET_LENGTH(unicode));
+    _NuitkaUnicode_FastCopyCharacters(copy, 0, unicode, 0, copy_length);
+    return copy;
+}
+
+#endif
+
 // We use older form code, make some backward compatible defines available.
 #if PYTHON_VERSION >= 0x390
 
@@ -311,6 +332,7 @@ static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length
 
 #endif
 
+#if PYTHON_VERSION < 0x3c0
 static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t length) {
     assert(PyUnicode_IS_COMPACT(unicode));
 
@@ -325,7 +347,7 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
 
     int share_wstr = _PyUnicode_SHARE_WSTR(unicode);
 
-    if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
+    if (unlikely(length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))) {
         PyErr_NoMemory();
         return NULL;
     }
@@ -336,6 +358,7 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
         _PyUnicode_UTF8(unicode) = NULL;
         _PyUnicode_UTF8_LENGTH(unicode) = 0;
     }
+
     _Py_DEC_REFTOTAL;
     _Py_ForgetReference(unicode);
 
@@ -346,10 +369,12 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
         PyErr_NoMemory();
         return NULL;
     }
+
     unicode = new_unicode;
     Nuitka_Py_NewReference(unicode);
 
     _PyUnicode_LENGTH(unicode) = length;
+
     if (share_wstr) {
         _PyUnicode_WSTR(unicode) = (wchar_t *)PyUnicode_DATA(unicode);
         if (!PyUnicode_IS_ASCII(unicode)) {
@@ -378,10 +403,11 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
         int share_wstr = _PyUnicode_SHARE_WSTR(unicode);
         int share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
 
-        if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
+        if (unlikely(length > (PY_SSIZE_T_MAX / char_size - 1))) {
             PyErr_NoMemory();
             return -1;
         }
+
         Py_ssize_t new_size = (length + 1) * char_size;
 
         if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode)) {
@@ -395,6 +421,7 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
             PyErr_NoMemory();
             return -1;
         }
+
         _PyUnicode_DATA_ANY(unicode) = data;
         if (share_wstr) {
             _PyUnicode_WSTR(unicode) = (wchar_t *)data;
@@ -433,15 +460,17 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
 }
 
 static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
+    assert(p_unicode != NULL);
+    assert(*p_unicode != NULL);
+    assert(0 <= length);
+
     PyObject *unicode = *p_unicode;
+    assert(PyUnicode_Check(unicode));
     Py_ssize_t old_length;
 
-#if PYTHON_VERSION < 0x3c0
     if (_PyUnicode_KIND(unicode) == PyUnicode_WCHAR_KIND) {
         old_length = PyUnicode_WSTR_LENGTH(unicode);
-    } else
-#endif
-    {
+    } else {
         old_length = PyUnicode_GET_LENGTH(unicode);
     }
 
@@ -457,23 +486,189 @@ static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
 
     if (!_NuitkaUnicode_modifiable(unicode)) {
         PyObject *copy = _NuitkaUnicode_resize_copy(unicode, length);
-        if (copy == NULL)
+        if (unlikely(copy == NULL)) {
             return -1;
+        }
         Py_DECREF(*p_unicode);
         *p_unicode = copy;
+
         return 0;
     }
 
     if (PyUnicode_IS_COMPACT(unicode)) {
         PyObject *new_unicode = _NuitkaUnicode_resize_compact(unicode, length);
-        if (new_unicode == NULL)
+
+        if (unlikely(new_unicode == NULL)) {
             return -1;
+        }
+
         *p_unicode = new_unicode;
         return 0;
     }
 
     return _NuitkaUnicode_resize_inplace(unicode, length);
 }
+#else
+
+#ifndef __NUITKA_NO_ASSERT__
+static void _Nuitka_unicode_fill_invalid(PyObject *unicode, Py_ssize_t old_length) {
+    int kind = PyUnicode_KIND(unicode);
+    Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
+    Py_ssize_t length = _PyUnicode_LENGTH(unicode);
+    if (length <= old_length)
+        return;
+    memset(data + old_length * kind, 0xff, (length - old_length) * kind);
+}
+#endif
+
+static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t length) {
+    assert(PyUnicode_IS_COMPACT(unicode));
+
+    Py_ssize_t char_size = PyUnicode_KIND(unicode);
+    Py_ssize_t struct_size;
+
+    if (PyUnicode_IS_ASCII(unicode)) {
+        struct_size = sizeof(PyASCIIObject);
+    } else {
+        struct_size = sizeof(PyCompactUnicodeObject);
+    }
+
+#ifndef __NUITKA_NO_ASSERT__
+    Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
+#endif
+
+    // assert(_Nuitka_unicode_modifiable(unicode));
+
+    if (unlikely(length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    Py_ssize_t new_size = (struct_size + (length + 1) * char_size);
+
+    if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+        PyObject_DEL(_PyUnicode_UTF8(unicode));
+        _PyUnicode_UTF8(unicode) = NULL;
+        _PyUnicode_UTF8_LENGTH(unicode) = 0;
+    }
+    _Py_ForgetReference(unicode);
+
+    PyObject *new_unicode = (PyObject *)PyObject_Realloc(unicode, new_size);
+    if (unlikely(new_unicode == NULL)) {
+        Nuitka_Py_NewReferenceNoTotal(unicode);
+
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    unicode = new_unicode;
+    Nuitka_Py_NewReferenceNoTotal(unicode);
+
+    _PyUnicode_LENGTH(unicode) = length;
+
+#ifndef __NUITKA_NO_ASSERT__
+    _Nuitka_unicode_fill_invalid(unicode, old_length);
+#endif
+
+    PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode), length, 0);
+    assert(_PyUnicode_CheckConsistency(unicode, 0));
+
+    return unicode;
+}
+
+static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
+    assert(!PyUnicode_IS_COMPACT(unicode));
+    assert(Py_REFCNT(unicode) == 1);
+
+#ifndef __NUITKA_NO_ASSERT__
+    Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
+#endif
+
+    void *data = _PyUnicode_DATA_ANY(unicode);
+    Py_ssize_t char_size = PyUnicode_KIND(unicode);
+    int share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
+
+    if (unlikely(length > (PY_SSIZE_T_MAX / char_size - 1))) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    Py_ssize_t new_size = (length + 1) * char_size;
+
+    if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+        PyObject_DEL(_PyUnicode_UTF8(unicode));
+        _PyUnicode_UTF8(unicode) = NULL;
+        _PyUnicode_UTF8_LENGTH(unicode) = 0;
+    }
+
+    data = (PyObject *)PyObject_REALLOC(data, new_size);
+    if (data == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    _PyUnicode_DATA_ANY(unicode) = data;
+    if (share_utf8) {
+        _PyUnicode_UTF8(unicode) = data;
+        _PyUnicode_UTF8_LENGTH(unicode) = length;
+    }
+    _PyUnicode_LENGTH(unicode) = length;
+    PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);
+#ifndef __NUITKA_NO_ASSERT__
+    _Nuitka_unicode_fill_invalid(unicode, old_length);
+#endif
+
+    /* check for integer overflow */
+    if (length > PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    assert(_PyUnicode_CheckConsistency(unicode, 0));
+    return 0;
+}
+
+static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
+    assert(p_unicode != NULL);
+    assert(*p_unicode != NULL);
+    assert(0 <= length);
+
+    PyObject *unicode = *p_unicode;
+    assert(PyUnicode_Check(unicode));
+    Py_ssize_t old_length;
+
+    old_length = PyUnicode_GET_LENGTH(unicode);
+    if (old_length == length) {
+        return 0;
+    }
+
+    if (length == 0) {
+        Py_SETREF(*p_unicode, const_str_empty);
+        return 0;
+    }
+
+    if (!_NuitkaUnicode_modifiable(unicode)) {
+        PyObject *copy = _NuitkaUnicode_resize_copy(unicode, length);
+        if (unlikely(copy == NULL)) {
+            return -1;
+        }
+        Py_SETREF(*p_unicode, copy);
+
+        return 0;
+    }
+
+    if (PyUnicode_IS_COMPACT(unicode)) {
+        PyObject *new_unicode = _NuitkaUnicode_resize_compact(unicode, length);
+
+        if (unlikely(new_unicode == NULL)) {
+            return -1;
+        }
+
+        *p_unicode = new_unicode;
+        return 0;
+    }
+
+    return _NuitkaUnicode_resize_inplace(unicode, length);
+}
+#endif
 
 PyObject *UNICODE_CONCAT(PyThreadState *tstate, PyObject *left, PyObject *right) {
     if (left == const_str_empty) {