Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/code_generation/templates/CodeTemplatesVariables.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Templates for the variable handling.
 
 """
@@ -59,7 +45,7 @@ template_write_local_inplace = """\
 """
 
 template_write_shared_inplace = """\
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 
@@ -76,7 +62,7 @@ template_write_local_clear_ref1 = """\
 template_write_shared_unclear_ref0 = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, %(tmp_name)s);
+    Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
     Py_XDECREF(old);
 }
 """
@@ -84,7 +70,7 @@ template_write_shared_unclear_ref0 = """\
 template_write_shared_unclear_ref1 = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, %(tmp_name)s);
+    Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
     Py_INCREF(%(tmp_name)s);
     Py_XDECREF(old);
 }
@@ -92,13 +78,13 @@ template_write_shared_unclear_ref1 = """\
 
 template_write_shared_clear_ref0 = """\
 assert(Nuitka_Cell_GET(%(identifier)s) == NULL);
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 template_write_shared_clear_ref1 = """\
 assert(Nuitka_Cell_GET(%(identifier)s) == NULL);
 Py_INCREF(%(tmp_name)s);
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 
@@ -110,7 +96,7 @@ Py_XDECREF(%(identifier)s);
 template_del_shared_tolerant = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
     Py_XDECREF(old);
 }
 """
@@ -126,7 +112,7 @@ if (likely(%(result)s)) {
 template_del_shared_intolerant = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
     Py_XDECREF(old);
 
     %(result)s = old != NULL;
@@ -142,7 +128,7 @@ Py_DECREF(%(identifier)s);
 template_del_shared_known = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
 
     CHECK_OBJECT(old);
     Py_DECREF(old);
@@ -171,7 +157,7 @@ template_read_mvar_unclear = """\
 """
 
 template_read_locals_dict_with_fallback = """\
-%(to_name)s = DICT_GET_ITEM0(tstate, %(locals_dict)s, %(var_name)s);
+%(to_name)s = %(dict_get_item)s(tstate, %(locals_dict)s, %(var_name)s);
 
 if (%(to_name)s == NULL) {
 %(fallback)s
@@ -183,7 +169,9 @@ template_read_locals_dict_without_fallback = """\
 """
 
 
-template_read_locals_mapping_with_fallback = """\
+# Fallback has no ref, so take one to agree with PyObject_GetItem doing
+# it.
+template_read_locals_mapping_with_fallback_no_ref = """\
 %(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
 
 if (%(to_name)s == NULL) {
@@ -196,6 +184,18 @@ if (%(to_name)s == NULL) {
 }
 """
 
+template_read_locals_mapping_with_fallback_ref = """\
+%(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
+
+if (%(to_name)s == NULL) {
+    if (CHECK_AND_CLEAR_KEY_ERROR_OCCURRED(tstate)) {
+%(fallback)s
+    } else {
+        goto %(exception_exit)s;
+    }
+}
+"""
+
 template_read_locals_mapping_without_fallback = """\
 %(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
 """
@@ -290,6 +290,94 @@ if (%(test_code)s) {
 }
 """
 
+template_module_variable_accessor_function = """\
+static PyObject *%(accessor_function_name)s(PyThreadState *tstate) {
+#if %(caching)s
+    PyObject *result;
+
+#if PYTHON_VERSION < 0x3b0
+    static uint64_t dict_version = 0;
+    static PyObject *cache_value = NULL;
+
+    if (moduledict_%(module_identifier)s->ma_version_tag == dict_version) {
+        CHECK_OBJECT_X(cache_value);
+        result = cache_value;
+    } else {
+        dict_version = moduledict_%(module_identifier)s->ma_version_tag;
+
+        result = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
+        cache_value = result;
+    }
+#else
+    static uint32_t dict_keys_version = 0xFFFFFFFF;
+    static Py_ssize_t cache_dk_index = 0;
+
+    PyDictKeysObject *dk = moduledict_%(module_identifier)s->ma_keys;
+    assert(DK_IS_UNICODE(dk));
+
+#if PYTHON_VERSION >= 0x3c0
+    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(tstate->interp, dk);
+#else
+    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(dk);
+#endif
+
+    if (current_dk_version != dict_keys_version) {
+        dict_keys_version = current_dk_version;
+        Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+        assert(hash != -1);
+
+        cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+    }
+
+    if (cache_dk_index >= 0) {
+        assert(dk->dk_kind != DICT_KEYS_SPLIT);
+
+        PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dk);
+
+        result = entries[cache_dk_index].me_value;
+
+        if (unlikely(result == NULL)) {
+            Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+            assert(hash != -1);
+
+            cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+
+            if (cache_dk_index >= 0) {
+                result = entries[cache_dk_index].me_value;
+            }
+        }
+    } else {
+        result = NULL;
+    }
+#endif
+
+#else
+    PyObject *result = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
+#endif
+
+    if (unlikely(result == NULL)) {
+        result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)%(var_name)s);
+    }
+
+    return result;
+}
+"""
+
 from . import TemplateDebugWrapper  # isort:skip
 
 TemplateDebugWrapper.checkDebug(globals())
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/code_generation/templates/TemplateDebugWrapper.py

@@ -1,26 +1,11 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Nuitka templates can have more checks that the normal '%' operation.
 
 This wraps strings with a class derived from "str" that does more checks.
 """
 
-
 from nuitka import Options
 from nuitka.__past__ import iterItems
 from nuitka.Tracing import optimization_logger
@@ -77,3 +62,19 @@ def enableDebug(globals_dict):
 def checkDebug(globals_dict):
     if Options.is_debug:
         enableDebug(globals_dict)
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/code_generation/templates/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
-#
-""" Dummy file to make this directory a package. """

nuitka/code_generation/templates_c/CodeTemplateCallsMethodPositional.c.j2

@@ -1,20 +1,5 @@
-{#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com                    #}
-{#                                                                              #}
-{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
-{#     integrates with CPython, but also works on its own.                      #}
-{#                                                                              #}
-{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
-{#     you may not use this file except in compliance with the License.         #}
-{#     You may obtain a copy of the License at                                  #}
-{#                                                                              #}
-{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
-{#                                                                              #}
-{#     Unless required by applicable law or agreed to in writing, software      #}
-{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
-{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
-{#     See the License for the specific language governing permissions and      #}
-{#     limitations under the License.                                           #}
-{#                                                                              #}
+{#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
+
 {% from 'HelperObjectTools.c.j2' import CHECK_OBJECTS %}
 {% macro call_function_with_args(called, args, args_count) %}
 {% if args_count == 0 %}
@@ -57,7 +42,7 @@ PyObject *CALL_METHOD_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject *s
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -277,7 +262,7 @@ PyObject *CALL_METHOD_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject *s
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 
@@ -319,3 +304,18 @@ PyObject *CALL_METHOD_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject *s
         return NULL;
     }
 }
+
+{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
+{#     integrates with CPython, but also works on its own.                      #}
+{#                                                                              #}
+{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
+{#     you may not use this file except in compliance with the License.         #}
+{#     You may obtain a copy of the License at                                  #}
+{#                                                                              #}
+{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
+{#                                                                              #}
+{#     Unless required by applicable law or agreed to in writing, software      #}
+{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
+{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
+{#     See the License for the specific language governing permissions and      #}
+{#     limitations under the License.                                           #}

nuitka/code_generation/templates_c/CodeTemplateCallsMixed.c.j2

@@ -1,29 +1,14 @@
-{#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com                    #}
-{#                                                                              #}
-{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
-{#     integrates with CPython, but also works on its own.                      #}
-{#                                                                              #}
-{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
-{#     you may not use this file except in compliance with the License.         #}
-{#     You may obtain a copy of the License at                                  #}
-{#                                                                              #}
-{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
-{#                                                                              #}
-{#     Unless required by applicable law or agreed to in writing, software      #}
-{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
-{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
-{#     See the License for the specific language governing permissions and      #}
-{#     limitations under the License.                                           #}
-{#                                                                              #}
+{#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
+
 {% from 'HelperObjectTools.c.j2' import CHECK_OBJECTS %}
 {% if not has_dict_values %}
 PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *kw_names) {
 {% elif args_count == 0 and has_dict_values %}
-PyObject *CALL_FUNCTION_WITH_NO_ARGS_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_NO_ARGS_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *kw_values, PyObject *kw_names) {
 {% elif not has_tuple_arg %}
-PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *const *kw_values, PyObject *kw_names) {
 {% else %}
-PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_POS_ARGS{{args_count}}_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args, PyObject *const *kw_values, PyObject *kw_names) {
     assert(PyTuple_CheckExact(pos_args));
     PyObject *const *args = &PyTuple_GET_ITEM(pos_args, 0);
 {% endif %}
@@ -108,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);
@@ -141,3 +126,18 @@ PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}_KWSPLIT(PyThreadState *tstate
 
     return Nuitka_CheckFunctionResult(tstate, called, result);
 }
+
+{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
+{#     integrates with CPython, but also works on its own.                      #}
+{#                                                                              #}
+{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
+{#     you may not use this file except in compliance with the License.         #}
+{#     You may obtain a copy of the License at                                  #}
+{#                                                                              #}
+{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
+{#                                                                              #}
+{#     Unless required by applicable law or agreed to in writing, software      #}
+{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
+{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
+{#     See the License for the specific language governing permissions and      #}
+{#     limitations under the License.                                           #}

nuitka/code_generation/templates_c/CodeTemplateCallsPositional.c.j2

@@ -1,20 +1,5 @@
-{#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com                    #}
-{#                                                                              #}
-{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
-{#     integrates with CPython, but also works on its own.                      #}
-{#                                                                              #}
-{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
-{#     you may not use this file except in compliance with the License.         #}
-{#     You may obtain a copy of the License at                                  #}
-{#                                                                              #}
-{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
-{#                                                                              #}
-{#     Unless required by applicable law or agreed to in writing, software      #}
-{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
-{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
-{#     See the License for the specific language governing permissions and      #}
-{#     limitations under the License.                                           #}
-{#                                                                              #}
+{#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
+
 {% from 'HelperObjectTools.c.j2' import CHECK_OBJECTS %}
 {% if args_count == 0 %}
 PyObject *CALL_FUNCTION_NO_ARGS(PyThreadState *tstate, PyObject *called) {
@@ -23,7 +8,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
     PyObject *const *args = &arg; // For easier code compatibility.
 {% else %}
 {% if has_tuple_arg %}
-PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}(PyThreadState *tstate, PyObject *called, PyObject *pos_args) {
+PyObject *CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(PyThreadState *tstate, PyObject *called, PyObject *pos_args) {
     assert(PyTuple_CheckExact(pos_args));
     assert(PyTuple_GET_SIZE(pos_args) == {{args_count}});
     PyObject *const *args = &PyTuple_GET_ITEM(pos_args, 0);
@@ -171,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);
 
@@ -245,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 %}
@@ -261,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 %}
@@ -278,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 %}
@@ -289,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 %}
@@ -309,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 %}
@@ -371,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 #}
@@ -448,7 +484,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
                             result = Nuitka_CallMethodFunctionPosArgs(tstate, (struct Nuitka_FunctionObject const *)init_method, obj, args, {{args_count}});
                         } else {
 {% if has_tuple_arg %}
-                            result = CALL_FUNCTION_WITH_POSARGS{{args_count}}(tstate, init_method, pos_args);
+                            result = CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(tstate, init_method, pos_args);
 {% else %}
                             result = CALL_FUNCTION_WITH_ARGS{{args_count}}(tstate, init_method, args);
 {% endif %}
@@ -475,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 %}
 
@@ -559,7 +595,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
             result = Nuitka_CallMethodFunctionPosArgs(tstate, (struct Nuitka_FunctionObject const *)init_method, obj, args, {{args_count}});
         } else {
 {% if has_tuple_arg %}
-            result = CALL_FUNCTION_WITH_POSARGS{{args_count}}(tstate, init_method, pos_args);
+            result = CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(tstate, init_method, pos_args);
 {% else %}
             result = CALL_FUNCTION_WITH_ARGS{{args_count}}(tstate, init_method, args);
 {% endif %}
@@ -610,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);
@@ -624,3 +660,18 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
 
     return result;
 }
+
+{#     Part of "Nuitka", an optimizing Python compiler that is compatible and   #}
+{#     integrates with CPython, but also works on its own.                      #}
+{#                                                                              #}
+{#     Licensed under the Apache License, Version 2.0 (the "License");          #}
+{#     you may not use this file except in compliance with the License.         #}
+{#     You may obtain a copy of the License at                                  #}
+{#                                                                              #}
+{#        http://www.apache.org/licenses/LICENSE-2.0                            #}
+{#                                                                              #}
+{#     Unless required by applicable law or agreed to in writing, software      #}
+{#     distributed under the License is distributed on an "AS IS" BASIS,        #}
+{#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #}
+{#     See the License for the specific language governing permissions and      #}
+{#     limitations under the License.                                           #}