Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

nuitka/code_generation/GlobalConstants.py

@@ -82,6 +82,7 @@ def getConstantDefaultPopulation():
         "staticmethod",
         "classmethod",
         "keys",
+        "get",
         # Arguments of __import__ built-in used in helper code.
         "name",
         "globals",
@@ -182,6 +183,10 @@ def getConstantDefaultPopulation():
         # Patching the types module.
         result.append("types")
 
+        # Converting module names
+        result.append("ascii")
+        result.append("punycode")
+
     if not Options.shallMakeModule():
         result.append("__main__")
 

nuitka/code_generation/GlobalsLocalsCodes.py

@@ -62,7 +62,7 @@ def generateBuiltinLocalsCode(to_name, expression, emit, context):
             # TODO: Creation is not needed for classes.
             emit(
                 """\
-if (%(locals_dict)s == NULL) %(locals_dict)s = MAKE_DICT_EMPTY();
+if (%(locals_dict)s == NULL) %(locals_dict)s = MAKE_DICT_EMPTY(tstate);
 %(to_name)s = %(locals_dict)s;
 Py_INCREF(%(to_name)s);"""
                 % {"to_name": value_name, "locals_dict": locals_declaration}
@@ -71,7 +71,7 @@ Py_INCREF(%(to_name)s);"""
 
             initial = False
         else:
-            emit("%s = MAKE_DICT_EMPTY();" % (to_name,))
+            emit("%s = MAKE_DICT_EMPTY(tstate);" % (to_name,))
 
             context.addCleanupTempName(value_name)
 

nuitka/code_generation/ListCodes.py

@@ -54,7 +54,7 @@ def generateListCreationCode(to_name, expression, emit, context):
 
         helper_code = generateElementCode(elements[0])
 
-        emit("%s = MAKE_LIST_EMPTY(%d);" % (result_name, len(elements)))
+        emit("%s = MAKE_LIST_EMPTY(tstate, %d);" % (result_name, len(elements)))
 
         needs_exception_exit = any(
             element.mayRaiseException(BaseException) for element in elements[1:]
@@ -187,7 +187,7 @@ def generateListOperationCopyCode(to_name, expression, emit, context):
     with withObjectCodeTemporaryAssignment(
         to_name, "list_copy_result", expression, emit, context
     ) as result_name:
-        emit("%s = LIST_COPY(%s);" % (result_name, list_arg_name))
+        emit("%s = LIST_COPY(tstate, %s);" % (result_name, list_arg_name))
 
         getErrorExitCode(
             check_name=result_name,

nuitka/code_generation/LocalsDictCodes.py

@@ -34,7 +34,7 @@ def generateSetLocalsDictCode(statement, emit, context):
 
     emit(
         """\
-%(locals_dict)s = MAKE_DICT_EMPTY();"""
+%(locals_dict)s = MAKE_DICT_EMPTY(tstate);"""
         % {"locals_dict": locals_declaration}
     )
 

nuitka/code_generation/ModuleCodes.py

@@ -116,6 +116,23 @@ def getModuleCode(
         module.getRuntimePackageValue() if is_dunder_main else ""
     )
 
+    if str is bytes:
+        module_dll_entry_point = "init" + module_identifier
+        module_def_size = -1
+    else:
+        try:
+            module_dll_entry_point = module_name.encode("ascii")
+            module_dll_entry_point_prefix = "PyInit_"
+            module_def_size = -1
+        except UnicodeEncodeError:
+            module_dll_entry_point = module_name.encode("punycode")
+            module_dll_entry_point_prefix = "PyInitU_"
+            module_def_size = 0
+
+        module_dll_entry_point = (
+            module_dll_entry_point_prefix + module_dll_entry_point.decode("ascii")
+        )
+
     return template % {
         "module_name_cstr": encodePythonStringToC(
             module_name.asString().encode("utf8")
@@ -138,6 +155,8 @@ def getModuleCode(
         "module_code_objects_init": indented(module_code_objects_init, 1),
         "constants_count": context.getConstantsCount(),
         "module_const_blob_name": module_const_blob_name,
+        "module_dll_entry_point": module_dll_entry_point,
+        "module_def_size": module_def_size,
     }
 
 

nuitka/code_generation/PackageResourceCodes.py

@@ -878,6 +878,20 @@ def generateOsPathDirnameCallCode(to_name, expression, emit, context):
     )
 
 
+def generateOsPathNormpathCallCode(to_name, expression, emit, context):
+    generateCAPIObjectCode(
+        to_name=to_name,
+        capi="OS_PATH_NORMPATH",
+        tstate=True,
+        arg_desc=(("path_arg", expression.subnode_path),),
+        may_raise=expression.mayRaiseException(BaseException),
+        conversion_check=decideConversionCheckNeeded(to_name, expression),
+        source_ref=expression.getCompatibleSourceReference(),
+        emit=emit,
+        context=context,
+    )
+
+
 def generateOsPathAbspathCallCode(to_name, expression, emit, context):
     generateCAPIObjectCode(
         to_name=to_name,

nuitka/code_generation/SliceCodes.py

@@ -259,7 +259,7 @@ def generateBuiltinSlice3Code(to_name, expression, emit, context):
         to_name, "slice_obj_value", expression, emit, context
     ) as result_name:
         emit(
-            "%s = MAKE_SLICE_OBJECT3(%s, %s, %s);"
+            "%s = MAKE_SLICE_OBJECT3(tstate, %s, %s, %s);"
             % (
                 result_name,
                 lower_name,
@@ -288,7 +288,7 @@ def generateBuiltinSlice2Code(to_name, expression, emit, context):
         to_name, "slice_obj_value", expression, emit, context
     ) as result_name:
         emit(
-            "%s = MAKE_SLICE_OBJECT2(%s, %s);"
+            "%s = MAKE_SLICE_OBJECT2(tstate, %s, %s);"
             % (
                 result_name,
                 lower_name,
@@ -316,7 +316,7 @@ def generateBuiltinSlice1Code(to_name, expression, emit, context):
         to_name, "slice_obj_value", expression, emit, context
     ) as result_name:
         emit(
-            "%s = MAKE_SLICE_OBJECT1(%s);"
+            "%s = MAKE_SLICE_OBJECT1(tstate, %s);"
             % (
                 result_name,
                 upper_name,

nuitka/code_generation/SubscriptCodes.py

@@ -136,7 +136,7 @@ def generateSubscriptLookupCode(to_name, expression, emit, context):
             )
 
 
-def generateSubscriptCheckCode(to_name, expression, emit, context):
+def generateMatchSubscriptCheckCode(to_name, expression, emit, context):
     subscribed = expression.subnode_expression
     subscript = expression.subnode_subscript
 
@@ -148,20 +148,12 @@ def generateSubscriptCheckCode(to_name, expression, emit, context):
         expression=subscript, emit=emit, context=context
     )
 
-    subscript_constant, integer_subscript = decideIntegerSubscript(subscript)
-
     res_name = context.getBoolResName()
 
-    if integer_subscript:
-        emit(
-            "%s = HAS_SUBSCRIPT_CONST(tstate, %s, %s, %s);"
-            % (res_name, subscribed_name, subscript_name, subscript_constant)
-        )
-    else:
-        emit(
-            "%s = HAS_SUBSCRIPT(tstate, %s, %s);"
-            % (res_name, subscribed_name, subscript_name)
-        )
+    emit(
+        "%s = MATCH_MAPPING_KEY(tstate, %s, %s);"
+        % (res_name, subscribed_name, subscript_name)
+    )
 
     getReleaseCodes((subscript_name, subscribed_name), emit, context)
 

nuitka/code_generation/TupleCodes.py

@@ -67,7 +67,7 @@ def getTupleCreationCode(to_name, elements, emit, context):
         helper_code = generateElementCode(elements[0])
 
         # TODO: Consider more compact tuple creation helpers
-        emit("%s = MAKE_TUPLE_EMPTY(%d);" % (to_name, len(elements)))
+        emit("%s = MAKE_TUPLE_EMPTY(tstate, %d);" % (to_name, len(elements)))
 
         needs_exception_exit = any(
             element.mayRaiseException(BaseException) for element in elements[1:]

nuitka/code_generation/c_types/CTypePyObjectPointers.py

@@ -181,12 +181,12 @@ class CPythonPyObjectPtrBase(CTypeBase):
                     )
                     ref_count = 1
                 else:
-                    code = "DICT_COPY(%s)" % context.getConstantCode(
+                    code = "DICT_COPY(tstate, %s)" % context.getConstantCode(
                         constant, deep_check=False
                     )
                     ref_count = 1
             else:
-                code = "MAKE_DICT_EMPTY()"
+                code = "MAKE_DICT_EMPTY(tstate)"
                 ref_count = 1
         elif type(constant) is set:
             if not may_escape:
@@ -222,12 +222,12 @@ class CPythonPyObjectPtrBase(CTypeBase):
                     if constant_size > 1 and all(
                         constant[i] is constant[0] for i in xrange(1, len(constant))
                     ):
-                        code = "MAKE_LIST_REPEATED(%s, %s)" % (
+                        code = "MAKE_LIST_REPEATED(tstate, %s, %s)" % (
                             constant_size,
                             context.getConstantCode(constant[0], deep_check=False),
                         )
                     elif constant_size < make_list_constant_direct_threshold:
-                        code = "MAKE_LIST%d(%s)" % (
+                        code = "MAKE_LIST%d(tstate, %s)" % (
                             constant_size,
                             ",".join(
                                 context.getConstantCode(constant[i], deep_check=False)
@@ -235,19 +235,19 @@ class CPythonPyObjectPtrBase(CTypeBase):
                             ),
                         )
                     elif constant_size < make_list_constant_hinted_threshold:
-                        code = "MAKE_LIST%d(%s)" % (
+                        code = "MAKE_LIST%d(tstate, %s)" % (
                             constant_size,
                             context.getConstantCode(constant, deep_check=False),
                         )
                     else:
-                        code = "LIST_COPY(%s)" % context.getConstantCode(
+                        code = "LIST_COPY(tstate, %s)" % context.getConstantCode(
                             constant, deep_check=False
                         )
                     ref_count = 1
             else:
                 # TODO: For the zero elements list, maybe have a dedicated function, which
                 # avoids a bit of tests, not sure we want LTO do this.
-                code = "MAKE_LIST_EMPTY(0)"
+                code = "MAKE_LIST_EMPTY(tstate, 0)"
                 ref_count = 1
         elif type(constant) is tuple:
             needs_deep = False

nuitka/code_generation/templates/CodeTemplatesConstants.py

@@ -17,7 +17,7 @@ PyObject *global_constants[%(global_constants_count)d];
 // Sentinel PyObject to be used for all our call iterator endings. It will
 // become a PyCObject pointing to NULL. It's address is unique, and that's
 // enough for us to use it as sentinel value.
-PyObject *_sentinel_value = NULL;
+PyObject *Nuitka_sentinel_value = NULL;
 
 PyObject *Nuitka_dunder_compiled_value = NULL;
 
@@ -243,14 +243,16 @@ void checkGlobalConstants(void) {
 #endif
 
 void createGlobalConstants(PyThreadState *tstate) {
-    if (_sentinel_value == NULL) {
+    if (Nuitka_sentinel_value == NULL) {
 #if PYTHON_VERSION < 0x300
-        _sentinel_value = PyCObject_FromVoidPtr(NULL, NULL);
+        Nuitka_sentinel_value = PyCObject_FromVoidPtr(NULL, NULL);
 #else
         // The NULL value is not allowed for a capsule, so use something else.
-        _sentinel_value = PyCapsule_New((void *)27, "sentinel", NULL);
+        Nuitka_sentinel_value = PyCapsule_New((void *)27, "sentinel", NULL);
 #endif
-        assert(_sentinel_value);
+        assert(Nuitka_sentinel_value);
+
+        Py_SET_REFCNT_IMMORTAL(Nuitka_sentinel_value);
 
         _createGlobalConstants(tstate);
     }

nuitka/code_generation/templates/CodeTemplatesLoader.py

@@ -124,7 +124,9 @@ void copyFrozenModulesTo(struct _frozen *destination) {
 #if PYTHON_VERSION >= 0x3b0
         destination->is_package = current->size < 0;
         destination->size = Py_ABS(destination->size);
+#if PYTHON_VERSION < 0x3d0
         destination->get_code = NULL;
+#endif
 #endif
         if (destination->name == NULL) break;
 

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -128,9 +128,9 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
         return NULL;
     }
 
-    if (Nuitka_Function_Check(func) == false) {
-        PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = PyThreadState_GET();
 
+    if (Nuitka_Function_Check(func) == false) {
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "not a compiled function");
         return NULL;
     }
@@ -140,7 +140,6 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
     int offset = Nuitka_Function_GetFunctionCodeIndex(function, function_table_%(module_identifier)s);
 
     if (unlikely(offset == -1)) {
-        PyThreadState *tstate = PyThreadState_GET();
 #if 0
         PRINT_STRING("Looking for:");
         PRINT_ITEM(func);
@@ -150,7 +149,7 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
         return NULL;
     }
 
-    PyObject *code_object_desc = MAKE_TUPLE_EMPTY(6);
+    PyObject *code_object_desc = MAKE_TUPLE_EMPTY(tstate, 6);
     PyTuple_SET_ITEM0(code_object_desc, 0, function->m_code_object->co_filename);
     PyTuple_SET_ITEM0(code_object_desc, 1, function->m_code_object->co_name);
     PyTuple_SET_ITEM(code_object_desc, 2, PyLong_FromLong(function->m_code_object->co_firstlineno));
@@ -161,14 +160,14 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
     CHECK_OBJECT_DEEP(code_object_desc);
 
 
-    PyObject *result = MAKE_TUPLE_EMPTY(8);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 8);
     PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));
     PyTuple_SET_ITEM(result, 1, code_object_desc);
     PyTuple_SET_ITEM0(result, 2, function->m_defaults);
 #if PYTHON_VERSION >= 0x300
     PyTuple_SET_ITEM0(result, 3, function->m_kwdefaults ? function->m_kwdefaults : Py_None);
 #else
-    PyTuple_SET_ITEM0(result, 3, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 3, Py_None);
 #endif
     PyTuple_SET_ITEM0(result, 4, function->m_doc != NULL ? function->m_doc : Py_None);
 
@@ -176,13 +175,13 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
         CHECK_OBJECT(function->m_constant_return_value);
         PyTuple_SET_ITEM0(result, 5, function->m_constant_return_value);
     } else {
-        PyTuple_SET_ITEM0(result, 5, Py_None);
+        PyTuple_SET_ITEM_IMMORTAL(result, 5, Py_None);
     }
 
 #if PYTHON_VERSION >= 0x300
     PyTuple_SET_ITEM0(result, 6, function->m_qualname);
 #else
-    PyTuple_SET_ITEM0(result, 6, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 6, Py_None);
 #endif
 
     PyObject *closure = PyObject_GetAttr(
@@ -277,7 +276,9 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         // In case of an extension module loaded into a process, we need to call
         // initialization here because that's the first and potentially only time
         // we are going called.
-
+#if PYTHON_VERSION > 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+        initNuitkaAllocators();
+#endif
         // Initialize the constant values used.
         _initBuiltinModule();
         createGlobalConstants(tstate);
@@ -506,15 +507,6 @@ template_module_external_entry_point = r"""
 #define NUITKA_MODULE_INIT_FUNCTION PyMODINIT_FUNC
 #endif
 
-/* The name of the entry point for DLLs changed between CPython versions, and
- * this is here to hide that.
- */
-#if PYTHON_VERSION < 0x300
-#define MOD_INIT_DECL(name) NUITKA_MODULE_INIT_FUNCTION init##name(void)
-#else
-#define MOD_INIT_DECL(name) NUITKA_MODULE_INIT_FUNCTION PyInit_##name(void)
-#endif
-
 static PyObject *orig_dunder_file_value;
 
 #if PYTHON_VERSION >= 0x300
@@ -548,20 +540,15 @@ static struct PyModuleDef mdef_%(module_identifier)s = {
     PyModuleDef_HEAD_INIT,
     NULL,                /* m_name, filled later */
     NULL,                /* m_doc */
-    -1,                  /* m_size */
+    %(module_def_size)s, /* m_size */
     NULL,                /* m_methods */
-    NULL,                /* m_reload */
+    NULL,                /* m_slots */
     NULL,                /* m_traverse */
     NULL,                /* m_clear */
     NULL,                /* m_free */
 };
 #endif
 
-/* The exported interface to CPython. On import of the module, this function
- * gets called. It has to have an exact function name, in cases it's a shared
- * library export. This is hidden behind the MOD_INIT_DECL macro.
- */
-
 // Actual name might be different when loaded as a package.
 static char const *module_full_name = %(module_name_cstr)s;
 
@@ -577,38 +564,18 @@ static void onModuleFileValueRelease(void *v) {
 }
 #endif
 
-MOD_INIT_DECL(%(module_identifier)s) {
-    if (_Py_PackageContext != NULL) {
-        module_full_name = _Py_PackageContext;
-    }
-
-#if PYTHON_VERSION < 0x300
-    PyObject *module = Py_InitModule4(
-        module_full_name,        // Module Name
-        NULL,                    // No methods initially, all are added
-                                 // dynamically in actual module code only.
-        NULL,                    // No "__doc__" is initially set, as it could
-                                 // not contain NUL this way, added early in
-                                 // actual code.
-        NULL,                    // No self for modules, we don't use it.
-        PYTHON_API_VERSION
-    );
-#else
-    mdef_%(module_identifier)s.m_name = module_full_name;
-    PyObject *module = PyModule_Create(&mdef_%(module_identifier)s);
-    CHECK_OBJECT(module);
+/* The exported interface to CPython. On import of the module, this function
+ * gets called. It has to have an exact function name, in cases it's a shared
+ * library export.
+ */
 
-    {
-        NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModuleString(module_full_name, module);
-        assert(res != false);
-    }
-#endif
 
+static PyObject *%(module_dll_entry_point)s_phase2(PyObject *module) {
     PyThreadState *tstate = PyThreadState_GET();
 
-#if PYTHON_VERSION < 0x300
-    modulecode_%(module_identifier)s(tstate, module, NULL);
+    PyObject *result = modulecode_%(module_identifier)s(tstate, module, NULL);
 
+#if PYTHON_VERSION < 0x300
     // Our "__file__" value will not be respected by CPython and one
     // way we can avoid it, is by having a capsule type, that when
     // it gets released, we are called and repair the value.
@@ -625,8 +592,6 @@ MOD_INIT_DECL(%(module_identifier)s) {
         );
     }
 #else
-    PyObject *result = modulecode_%(module_identifier)s(tstate, module, NULL);
-
     if (result != NULL) {
         // Make sure we undo the change of the "__file__" attribute during importing. We do not
         // know how to achieve it for Python2 though. TODO: Find something for Python2 too.
@@ -635,8 +600,69 @@ MOD_INIT_DECL(%(module_identifier)s) {
 
         orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
     }
+#endif
 
     return result;
+}
+
+#if %(module_def_size)s >= 0
+static int %(module_dll_entry_point)s_slot(PyObject *module) {
+    PyObject *result = %(module_dll_entry_point)s_phase2(module);
+
+    if (result == NULL) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+#endif
+
+NUITKA_MODULE_INIT_FUNCTION (%(module_dll_entry_point)s)(void) {
+    if (_Py_PackageContext != NULL) {
+        if (strcmp(module_full_name, _Py_PackageContext) != 0) {
+            module_full_name = strdup(_Py_PackageContext);
+        }
+    }
+
+#if PYTHON_VERSION < 0x300
+    PyObject *module = Py_InitModule4(
+        module_full_name,        // Module Name
+        NULL,                    // No methods initially, all are added
+                                 // dynamically in actual module code only.
+        NULL,                    // No "__doc__" is initially set, as it could
+                                 // not contain NUL this way, added early in
+                                 // actual code.
+        NULL,                    // No self for modules, we don't use it.
+        PYTHON_API_VERSION
+    );
+#else
+    mdef_%(module_identifier)s.m_name = module_full_name;
+
+#if %(module_def_size)s == -1
+    PyObject *module = PyModule_Create(&mdef_%(module_identifier)s);
+    CHECK_OBJECT(module);
+
+    {
+        NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModuleString(module_full_name, module);
+        assert(res != false);
+    }
+
+#endif
+#endif
+
+#if %(module_def_size)s >= 0
+    static PyModuleDef_Slot _module_slots[] = {
+        {Py_mod_exec, %(module_dll_entry_point)s_slot},
+        {0, NULL}
+    };
+
+    mdef_%(module_identifier)s.m_slots = _module_slots;
+
+    return PyModuleDef_Init(&mdef_%(module_identifier)s);
+#elif PYTHON_VERSION >= 0x300
+    return %(module_dll_entry_point)s_phase2(module);
+#else
+    %(module_dll_entry_point)s_phase2(module);
 #endif
 }
 """

nuitka/code_generation/templates_c/CodeTemplateCallsMixed.c.j2

@@ -93,7 +93,7 @@ PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}_KWSPLIT(PyThreadState *tstate
 {% if args_count == 0 %}
     PyObject *pos_args = const_tuple_empty;
 {% elif not has_tuple_arg or not has_dict_values %}
-    PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% endif %}
 
     PyObject *named_args = _PyDict_NewPresized(nkwargs);

nuitka/code_generation/templates_c/CodeTemplateCallsPositional.c.j2

@@ -156,6 +156,56 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
         }
 #if !defined(_NUITKA_EXPERIMENTAL_DISABLE_CFUNCTION_CALL_OPT)
     } else if (PyCFunction_CheckExact(called)) {
+#if PYTHON_VERSION >= 0x380
+#ifdef _NUITKA_FULL_COMPAT
+        if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) {
+            return NULL;
+        }
+#endif
+
+        int flags = PyCFunction_GET_FLAGS(called);
+
+        PyObject *result;
+
+        if (!(flags & METH_VARARGS)) {
+            vectorcallfunc func = *((vectorcallfunc *)(((char *)called) + Py_TYPE(called)->tp_vectorcall_offset));
+
+            assert(func != NULL);
+{% if args_count == 0 %}
+            result = func(called, NULL, 0, NULL);
+{% else %}
+            result = func(called, args, {{args_count}}, NULL);
+{% endif %}
+
+            CHECK_OBJECT_X(result);
+        } else {
+            PyCFunction method = PyCFunction_GET_FUNCTION(called);
+            PyObject *self = PyCFunction_GET_SELF(called);
+
+{% if not has_tuple_arg and args_count != 0 %}
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
+{% elif not has_tuple_arg %}
+            PyObject *pos_args = const_tuple_empty;
+{% endif %}
+
+            if (flags & METH_KEYWORDS) {
+                result = (*(PyCFunctionWithKeywords)(void(*)(void))method)(self, pos_args, NULL);
+            } else {
+                result = (*method)(self, pos_args);
+            }
+
+{% if not has_tuple_arg and args_count != 0 %}
+            Py_DECREF(pos_args);
+{% endif %}
+        }
+
+#ifdef _NUITKA_FULL_COMPAT
+        Py_LeaveRecursiveCall();
+#endif
+        CHECK_OBJECT_X(result);
+
+        return Nuitka_CheckFunctionResult(tstate, called, result);
+#else
         // Try to be fast about wrapping the arguments.
         int flags = PyCFunction_GET_FLAGS(called) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
 
@@ -230,7 +280,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
 
 #if PYTHON_VERSION < 0x360
 {% if not has_tuple_arg and args_count != 0 %}
-            PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% elif not has_tuple_arg %}
             PyObject *pos_args = const_tuple_empty;
 {% endif %}
@@ -246,7 +296,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
 #else
             if (flags == (METH_VARARGS|METH_KEYWORDS)) {
 {% if not has_tuple_arg and args_count != 0 %}
-            PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% elif not has_tuple_arg %}
             PyObject *pos_args = const_tuple_empty;
 {% endif %}
@@ -263,7 +313,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
 {% endif %}
 #else
 {% if not has_tuple_arg and args_count != 0 %}
-            PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% elif not has_tuple_arg %}
             PyObject *pos_args = const_tuple_empty;
 {% endif %}
@@ -274,7 +324,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
 #endif
             } else {
 {% if not has_tuple_arg and args_count != 0 %}
-            PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+            PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% elif not has_tuple_arg %}
             PyObject *pos_args = const_tuple_empty;
 {% endif %}
@@ -294,7 +344,8 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
             return Nuitka_CheckFunctionResult(tstate, called, result);
         }
 #endif
-#if !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
+#endif
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
     } else if (PyFunction_Check(called)) {
 #if PYTHON_VERSION < 0x3b0
 {% if args_count == 0 %}
@@ -356,7 +407,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
                 CHECK_OBJECT(obj);
             } else {
 {% if not has_tuple_arg and args_count != 0 %}
-                pos_args = MAKE_TUPLE(args, {{args_count}});
+                pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% endif %}
                 obj = called_type->tp_new(called_type, pos_args, NULL);
                 {# TODO: obj = _Py_CheckFunctionResult(obj) for Python3 in debug mode #}
@@ -460,7 +511,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
                     } else {
 {% if not has_tuple_arg and args_count != 0 %}
                         if (pos_args == NULL) {
-                            pos_args = MAKE_TUPLE(args, {{args_count}});
+                            pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
                         }
 {% endif %}
 
@@ -595,7 +646,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
     PyObject *result = CALL_FUNCTION(tstate, called, const_tuple_empty, NULL);
 {% else %}
 {% if not has_tuple_arg %}
-    PyObject *pos_args = MAKE_TUPLE(args, {{args_count}});
+    PyObject *pos_args = MAKE_TUPLE(tstate, args, {{args_count}});
 {% endif %}
 
     PyObject *result = CALL_FUNCTION(tstate, called, pos_args, NULL);