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

nuitka/build/static_src/HelpersExceptions.c

@@ -46,13 +46,17 @@ void FORMAT_UNBOUND_LOCAL_ERROR(PyObject **exception_type, PyObject **exception_
     *exception_type = PyExc_UnboundLocalError;
     Py_INCREF(*exception_type);
 
-#if PYTHON_VERSION < 0x3b0
+#if PYTHON_VERSION < 0x300
     char const *message = "local variable '%s' referenced before assignment";
+    *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
+#elif PYTHON_VERSION < 0x3b0
+    char const *message = "local variable '%U' referenced before assignment";
+    *exception_value = Nuitka_String_FromFormat(message, variable_name);
 #else
-    char const *message = "cannot access local variable '%s' where it is not associated with a value";
+    char const *message = "cannot access local variable '%U' where it is not associated with a value";
+    *exception_value = Nuitka_String_FromFormat(message, variable_name);
 #endif
 
-    *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
     CHECK_OBJECT(*exception_value);
 }
 
@@ -97,6 +101,95 @@ static PyObject *_Nuitka_Err_CreateException(PyThreadState *tstate, PyObject *ex
 // 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.
+
+#if PYTHON_VERSION >= 0x3d0
+// TODO: Merge with old branch for enhancements.
+void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObject **val, PyTracebackObject **tb) {
+    int recursion_depth = 0;
+    tstate->recursion_headroom++;
+
+    PyObject *type, *value;
+    PyTracebackObject *initial_tb;
+
+restart:
+    type = *exc;
+
+    if (type == NULL) {
+        tstate->recursion_headroom--;
+        return;
+    }
+
+    value = *val;
+
+    if (!value) {
+        Py_INCREF_IMMORTAL(Py_None);
+        value = Py_None;
+    }
+
+    if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+
+        int is_subclass = 0;
+
+        if (PyExceptionInstance_Check(value)) {
+            instance_class = PyExceptionInstance_Class(value);
+
+            is_subclass = PyObject_IsSubclass(instance_class, type);
+            if (is_subclass < 0) {
+                goto error;
+            }
+        }
+
+        if (!is_subclass) {
+            PyObject *fixed_value = _Nuitka_Err_CreateException(tstate, type, value);
+
+            if (fixed_value == NULL) {
+                goto error;
+            }
+
+            Py_SETREF(value, fixed_value);
+        } else if (instance_class != type) {
+            Py_SETREF(type, Py_NewRef(instance_class));
+        }
+    }
+    *exc = type;
+    *val = value;
+    tstate->recursion_headroom--;
+    return;
+
+error:
+    Py_DECREF(type);
+    Py_DECREF(value);
+    recursion_depth++;
+    if (recursion_depth == 32) {
+        _PyErr_SetString(tstate, PyExc_RecursionError,
+                         "maximum recursion depth exceeded "
+                         "while normalizing an exception");
+    }
+
+    initial_tb = *tb;
+
+    FETCH_ERROR_OCCURRED(tstate, exc, val, tb);
+
+    assert(*exc != NULL);
+    if (initial_tb != NULL) {
+        if (*tb == NULL)
+            *tb = initial_tb;
+        else
+            Py_DECREF(initial_tb);
+    }
+    if (recursion_depth >= 32 + 2) {
+        if (PyErr_GivenExceptionMatches(*exc, PyExc_MemoryError)) {
+            Py_FatalError("Cannot recover from MemoryErrors "
+                          "while normalizing exceptions.");
+        } else {
+            Py_FatalError("Cannot recover from the recursive normalization "
+                          "of an exception.");
+        }
+    }
+    goto restart;
+}
+#else
 void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObject **val, PyTracebackObject **tb) {
     PyObject *type = *exc;
 
@@ -107,11 +200,8 @@ 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);
+        Py_INCREF_IMMORTAL(value);
     }
 
     // Normalize the exception from class to instance
@@ -182,11 +272,16 @@ error:
 #endif
 }
 
+#endif
+
 // Raise NameError for a given variable name.
 void SET_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name) {
+#if PYTHON_VERSION >= 0x300
+    PyObject *exception_value_str = Nuitka_String_FromFormat("name '%U' is not defined", variable_name);
+#else
     PyObject *exception_value_str =
         Nuitka_String_FromFormat("name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-
+#endif
     PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
     Py_DECREF(exception_value_str);
 
@@ -200,9 +295,12 @@ void SET_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate, PyObject *variable_
 // 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) {
+#if PYTHON_VERSION >= 0x300
+    PyObject *exception_value_str = Nuitka_String_FromFormat("global name '%U' is not defined", variable_name);
+#else
     PyObject *exception_value_str =
         Nuitka_String_FromFormat("global name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-
+#endif
     PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_NameError, exception_value_str);
     Py_DECREF(exception_value_str);
 

nuitka/build/static_src/HelpersFilesystemPaths.c

@@ -34,6 +34,62 @@
 #include "nuitka/filesystem_paths.h"
 #include "nuitka/safe_string_ops.h"
 
+#if defined(__OpenBSD__)
+void _getBinaryPath2(char *epath) {
+    int mib[4];
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC_ARGS;
+    mib[2] = getpid();
+    mib[3] = KERN_PROC_ARGV;
+
+    size_t len;
+
+    if (sysctl(mib, 4, NULL, &len, NULL, 0) < 0) {
+        abort();
+    }
+
+    char **argv = argv = malloc(len);
+    if (argv == NULL) {
+        abort();
+    }
+
+    if (sysctl(mib, 4, argv, &len, NULL, 0) < 0) {
+        abort();
+    }
+
+    const char *comm = argv[0];
+
+    if (*comm == '/' || *comm == '.') {
+        if (realpath(comm, epath) == NULL) {
+            abort();
+        }
+    } else {
+        char *sp;
+        char *xpath = strdup(getenv("PATH"));
+        char *path = strtok_r(xpath, ":", &sp);
+        struct stat st;
+
+        if (xpath == NULL) {
+            abort();
+        }
+
+        while (path) {
+            snprintf(epath, PATH_MAX, "%s/%s", path, comm);
+
+            if (!stat(epath, &st) && (st.st_mode & S_IXUSR)) {
+                break;
+            }
+
+            path = strtok_r(NULL, ":", &sp);
+        }
+
+        free(xpath);
+    }
+
+    free(argv);
+}
+#endif
+
 filename_char_t *getBinaryPath(void) {
     static filename_char_t binary_filename[MAXPATHLEN];
 
@@ -49,7 +105,9 @@ filename_char_t *getBinaryPath(void) {
     if (res != 0) {
         abort();
     }
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
+#elif defined(__OpenBSD__)
+    _getBinaryPath2(binary_filename);
+#elif defined(__FreeBSD__)
     /* Not all of FreeBSD has /proc file system, so use the appropriate
      * "sysctl" instead.
      */
@@ -167,7 +225,7 @@ int64_t getFileSize(FILE_HANDLE file_handle) {
 #if defined(__APPLE__)
 #include <copyfile.h>
 #else
-#if defined(__MSYS__) || defined(__HAIKU__)
+#if defined(__MSYS__) || defined(__HAIKU__) || defined(__OpenBSD__)
 static bool sendfile(int output_file, int input_file, off_t *bytesCopied, size_t count) {
     char buffer[32768];
 
@@ -617,8 +675,10 @@ 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(__FreeBSD__) || defined(__OpenBSD__)
+#elif defined(__OpenBSD__)
+    _getBinaryPath2(binary_filename_target);
+    resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
+#elif defined(__FreeBSD__)
     /* Not all of FreeBSD has /proc file system, so use the appropriate
      * "sysctl" instead.
      */

nuitka/build/static_src/HelpersFloats.c

@@ -35,34 +35,40 @@ PyObject *TO_FLOAT(PyObject *value) {
 
 #if NUITKA_FLOAT_HAS_FREELIST
 
-static struct _Py_float_state *_Nuitka_Py_get_float_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->float_state;
-}
-
-static PyFloatObject *_Nuitka_AllocatePyFloatObject(void) {
-    struct _Py_float_state *state = _Nuitka_Py_get_float_state();
+static PyFloatObject *_Nuitka_AllocatePyFloatObject(PyThreadState *tstate) {
+    // This is the CPython name, spell-checker: ignore numfree
 
-    PyFloatObject *result_float = state->free_list;
+#if PYTHON_VERSION < 0x3d0
+    struct _Py_float_state *state = &tstate->interp->float_state;
+    PyFloatObject **free_list = &state->free_list;
+    int *numfree = &state->numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_float_freelist *state = &freelists->floats;
+    PyFloatObject **free_list = &state->items;
+    int *numfree = &state->numfree;
+#endif
+    PyFloatObject *result_float = *free_list;
 
     if (result_float) {
-        state->free_list = (PyFloatObject *)Py_TYPE(result_float);
-        state->numfree -= 1;
-
-        Py_SET_TYPE(result_float, &PyFloat_Type);
+        (*numfree) -= 1;
+        *free_list = (PyFloatObject *)Py_TYPE(result_float);
     } else {
-        result_float = (PyFloatObject *)PyObject_Malloc(sizeof(PyFloatObject));
+        result_float = (PyFloatObject *)NuitkaObject_Malloc(sizeof(PyFloatObject));
     }
 
     Py_SET_TYPE(result_float, &PyFloat_Type);
     Nuitka_Py_NewReference((PyObject *)result_float);
+
     assert(result_float != NULL);
 
     return result_float;
 }
 
 PyObject *MAKE_FLOAT_FROM_DOUBLE(double value) {
-    PyFloatObject *result = _Nuitka_AllocatePyFloatObject();
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyFloatObject *result = _Nuitka_AllocatePyFloatObject(tstate);
 
     PyFloat_SET_DOUBLE(result, value);
     return (PyObject *)result;

nuitka/build/static_src/HelpersImport.c

@@ -421,7 +421,7 @@ PyObject *IMPORT_NAME_OR_MODULE(PyThreadState *tstate, PyObject *module, PyObjec
             }
 
             if (level_int > 0) {
-                PyObject *fromlist = MAKE_TUPLE1(import_name);
+                PyObject *fromlist = MAKE_TUPLE1(tstate, import_name);
 
                 result = IMPORT_MODULE5(tstate, const_str_empty, globals, globals, fromlist, level);
 

nuitka/build/static_src/HelpersJitSources.c

@@ -19,7 +19,7 @@ void SET_UNCOMPILED_FUNCTION_SOURCE_DICT(PyObject *name, PyObject *source) {
 
         DROP_ERROR_OCCURRED(tstate);
 
-        uncompiled_function_sources_dict = MAKE_DICT_EMPTY();
+        uncompiled_function_sources_dict = MAKE_DICT_EMPTY(tstate);
 
         PyObject_SetAttrString((PyObject *)builtin_module, uncompiled_sources_dict_attribute_name,
                                uncompiled_function_sources_dict);

nuitka/build/static_src/HelpersLists.c

@@ -15,22 +15,30 @@
 static PyObject *Nuitka_LongFromCLong(long ival);
 
 #if NUITKA_LIST_HAS_FREELIST
-static struct _Py_list_state *_Nuitka_Py_get_list_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->list;
-}
 
-PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
+PyObject *MAKE_LIST_EMPTY(PyThreadState *tstate, Py_ssize_t size) {
     assert(size >= 0);
 
-    struct _Py_list_state *state = _Nuitka_Py_get_list_state();
-    PyListObject *result_list;
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+    return PyList_New(size);
+#else
+    // This is the CPython name, spell-checker: ignore numfree
 
-    assert(state->numfree >= 0);
+#if PYTHON_VERSION < 0x3d0
+    PyListObject **items = tstate->interp->list.free_list;
+    int *numfree = &tstate->interp->list.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_list_freelist *state = &freelists->lists;
+    PyListObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+    assert(*numfree >= 0);
+    PyListObject *result_list;
 
-    if (state->numfree) {
-        state->numfree -= 1;
-        result_list = state->free_list[state->numfree];
+    if (*numfree) {
+        (*numfree) -= 1;
+        result_list = items[*numfree];
 
         Nuitka_Py_NewReference((PyObject *)result_list);
     } else {
@@ -39,7 +47,7 @@ PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
 
     // Elements are allocated separately.
     if (size > 0) {
-        result_list->ob_item = (PyObject **)PyMem_Calloc(size, sizeof(PyObject *));
+        result_list->ob_item = (PyObject **)NuitkaMem_Calloc(size, sizeof(PyObject *));
 
         if (unlikely(result_list->ob_item == NULL)) {
             Py_DECREF(result_list);
@@ -55,15 +63,16 @@ PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
     Nuitka_GC_Track(result_list);
 
     return (PyObject *)result_list;
+#endif
 }
 #endif
 
-PyObject *LIST_COPY(PyObject *list) {
+PyObject *LIST_COPY(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
 
     Py_ssize_t size = PyList_GET_SIZE(list);
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -378,7 +387,8 @@ bool LIST_REMOVE(PyObject *target, PyObject *item) {
 
     CHECK_OBJECT(item);
 
-#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT && 0
+    // TODO: This is not exposed, would need to delete as slice instead.
     int res = PyList_Remove(target, item);
     return res == 0;
 #else
@@ -519,7 +529,7 @@ static PyObject *_LIST_INDEX_COMMON(PyThreadState *tstate, PyListObject *list, P
 
 #if PYTHON_VERSION < 0x300
     PyObject *err_format = PyString_FromString("%r is not in list");
-    PyObject *format_tuple = MAKE_TUPLE1_0(item);
+    PyObject *format_tuple = MAKE_TUPLE1_0(tstate, item);
     PyObject *err_string = PyString_Format(err_format, format_tuple);
     Py_DECREF(format_tuple);
 
@@ -716,7 +726,7 @@ void LIST_REVERSE(PyObject *list) {
     }
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x340 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT)
 static bool allocateListItems(PyListObject *list, Py_ssize_t size) {
     PyObject **items = PyMem_New(PyObject *, size);
 
@@ -735,7 +745,7 @@ static bool allocateListItems(PyListObject *list, Py_ssize_t size) {
 PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
     // Can leave the size hinting to later functions, because the list is allocated empty without
     // items, and when then extending, etc. length hints can be used.
-    PyObject *list = MAKE_LIST_EMPTY(0);
+    PyObject *list = MAKE_LIST_EMPTY(tstate, 0);
 
 #if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
     PyObject *result = _PyList_Extend((PyListObject *)list, iterable);
@@ -748,7 +758,7 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
     }
 #else
 #if PYTHON_VERSION >= 0x340
-    if (_PyObject_HasLen(iterable)) {
+    if (Nuitka_PyObject_HasLen(iterable)) {
         Py_ssize_t iter_len = Nuitka_PyObject_Size(iterable);
 
         if (unlikely(iter_len == -1)) {

nuitka/build/static_src/HelpersListsGenerated.c

@@ -7,9 +7,9 @@
 #include "nuitka/prelude.h"
 #endif
 
-PyObject *MAKE_LIST1(PyObject *arg0) {
+PyObject *MAKE_LIST1(PyThreadState *tstate, PyObject *arg0) {
 
-    PyObject *result = MAKE_LIST_EMPTY(1);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 1);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -21,9 +21,9 @@ PyObject *MAKE_LIST1(PyObject *arg0) {
 
     return result;
 }
-PyObject *MAKE_LIST2(PyObject *arg0, PyObject *arg1) {
+PyObject *MAKE_LIST2(PyThreadState *tstate, PyObject *arg0, PyObject *arg1) {
 
-    PyObject *result = MAKE_LIST_EMPTY(2);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 2);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -39,9 +39,9 @@ PyObject *MAKE_LIST2(PyObject *arg0, PyObject *arg1) {
 
     return result;
 }
-PyObject *MAKE_LIST3(PyObject *arg0, PyObject *arg1, PyObject *arg2) {
+PyObject *MAKE_LIST3(PyThreadState *tstate, PyObject *arg0, PyObject *arg1, PyObject *arg2) {
 
-    PyObject *result = MAKE_LIST_EMPTY(3);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 3);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -61,12 +61,12 @@ PyObject *MAKE_LIST3(PyObject *arg0, PyObject *arg1, PyObject *arg2) {
 
     return result;
 }
-PyObject *MAKE_LIST4(PyObject *list) {
+PyObject *MAKE_LIST4(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 4);
 
-    PyObject *result = MAKE_LIST_EMPTY(4);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 4);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -95,12 +95,12 @@ PyObject *MAKE_LIST4(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST5(PyObject *list) {
+PyObject *MAKE_LIST5(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 5);
 
-    PyObject *result = MAKE_LIST_EMPTY(5);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 5);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -134,12 +134,12 @@ PyObject *MAKE_LIST5(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST6(PyObject *list) {
+PyObject *MAKE_LIST6(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 6);
 
-    PyObject *result = MAKE_LIST_EMPTY(6);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 6);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -178,12 +178,12 @@ PyObject *MAKE_LIST6(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST7(PyObject *list) {
+PyObject *MAKE_LIST7(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 7);
 
-    PyObject *result = MAKE_LIST_EMPTY(7);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 7);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -227,12 +227,12 @@ PyObject *MAKE_LIST7(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST8(PyObject *list) {
+PyObject *MAKE_LIST8(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 8);
 
-    PyObject *result = MAKE_LIST_EMPTY(8);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 8);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -281,12 +281,12 @@ PyObject *MAKE_LIST8(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST9(PyObject *list) {
+PyObject *MAKE_LIST9(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 9);
 
-    PyObject *result = MAKE_LIST_EMPTY(9);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 9);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -340,12 +340,12 @@ PyObject *MAKE_LIST9(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST10(PyObject *list) {
+PyObject *MAKE_LIST10(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 10);
 
-    PyObject *result = MAKE_LIST_EMPTY(10);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 10);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -404,12 +404,12 @@ PyObject *MAKE_LIST10(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST11(PyObject *list) {
+PyObject *MAKE_LIST11(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 11);
 
-    PyObject *result = MAKE_LIST_EMPTY(11);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 11);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -473,12 +473,12 @@ PyObject *MAKE_LIST11(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST12(PyObject *list) {
+PyObject *MAKE_LIST12(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 12);
 
-    PyObject *result = MAKE_LIST_EMPTY(12);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 12);
 
     if (unlikely(result == NULL)) {
         return NULL;

nuitka/build/static_src/HelpersMatching.c

@@ -42,10 +42,7 @@ PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t
                 return NULL;
             }
 
-            // TODO: Specialize for single element maybe, but LTO solves
-            // this just fine.
-            PyObject *elements[1] = {matched};
-            return MAKE_TUPLE(elements, 1);
+            return MAKE_TUPLE1(tstate, matched);
         }
 
         actual = 0;
@@ -58,7 +55,7 @@ PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t
         return NULL;
     }
 
-    PyObject *result = MAKE_TUPLE_EMPTY_VAR(actual);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, actual);
 
     for (Py_ssize_t i = 0; i < max_allowed; i++) {
         PyObject *arg_name = PyTuple_GET_ITEM(match_args, i);
@@ -89,6 +86,36 @@ PyObject *MATCH_CLASS_ARGS(PyThreadState *tstate, PyObject *matched, Py_ssize_t
     Py_DECREF(match_args);
     return result;
 }
+
+int 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".
+    PyObject *get_method = LOOKUP_ATTRIBUTE(tstate, map, const_str_plain_get);
+    if (unlikely(get_method == NULL)) {
+        return -1;
+    }
+
+    PyObject *args[] = {key, Nuitka_sentinel_value};
+
+    PyObject *value = CALL_FUNCTION_WITH_ARGS2(tstate, get_method, args);
+
+    Py_XDECREF(get_method);
+
+    if (unlikely(value == NULL)) {
+        return -1;
+    }
+
+    if (value == Nuitka_sentinel_value) {
+        Py_DECREF_IMMORTAL(value);
+
+        return 0;
+    }
+
+    Py_DECREF(value);
+
+    return 1;
+}
+
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //