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

nuitka/build/Backend.scons

@@ -39,7 +39,13 @@ from nuitka.Tracing import (
     setQuiet,
 )
 from nuitka.utils.Execution import check_output
-from nuitka.utils.FileOperations import getExternalUsePath
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    deleteFile,
+    getExternalUsePath,
+    getFilenameExtension,
+    isFilesystemEncodable,
+)
 from nuitka.utils.Json import loadJsonFromFilename
 from nuitka.utils.Utils import (
     isDebianBasedLinux,
@@ -104,18 +110,12 @@ source_dir = getArgumentRequired("source_dir")
 nuitka_src = getArgumentRequired("nuitka_src")
 static_src = os.path.join(source_dir, "static")
 
-# The name of executable or extension module that we produce.
-result_base_path = getArgumentRequired("result_name")
-
-# The name of executable that we produce (in executable mode).
-result_exe = getArgumentDefaulted("result_exe", None)
+# The name of executable that we are supposed to produce.
+result_exe = getArgumentRequired("result_exe")
 
 # Name of the main program (in executable mode, typically __main__ but can be in a package too.)
 main_module_name = getArgumentDefaulted("main_module_name", "__main__")
 
-# The suffix for an extension module (in module mode).
-module_suffix = getArgumentDefaulted("module_suffix", None)
-
 # Full names shall be used, no remapping for cacheable filenames.
 full_names = getArgumentBool("full_names", False)
 
@@ -167,8 +167,8 @@ lto_mode = getArgumentDefaulted("lto_mode", "auto")
 # PGO mode: Use profile guided optimization of C compiler if available.
 pgo_mode = getArgumentDefaulted("pgo_mode", "no")
 
-# Windows subsystem mode: Disable console for windows builds.
-disable_console = getArgumentBool("disable_console", False)
+# Console mode specified
+console_mode = getArgumentDefaulted("console_mode", "attach")
 
 # Windows might be running a Python whose DLL we have to use.
 uninstalled_python = getArgumentBool("uninstalled_python", False)
@@ -354,7 +354,7 @@ env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.standalone_mode = standalone_mode
 env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
-env.disable_console = disable_console
+env.console_mode = console_mode
 env.source_dir = source_dir
 env.nuitka_src = nuitka_src
 env.low_memory = low_memory
@@ -470,6 +470,8 @@ if env.debug_mode:
                     "-Werror",
                 ]
             )
+        else:
+            env.Append(CCFLAGS=["-Wno-unused-but-set-variable"])
 
         env.Append(
             CCFLAGS=[
@@ -504,6 +506,9 @@ if env.debug_mode:
         if python_version >= (3, 4):
             env.Append(CCFLAGS=["/wd4512", "/wd4510", "/wd4610"])
 
+        if python_version >= (3, 13):
+            env.Append(CCFLAGS=["/wd4324"])
+
         # We use null arrays in our structure Python declarations, which C11 does
         # not really allow, but should work.
         env.Append(CCFLAGS=["/wd4200"])
@@ -637,6 +642,9 @@ not satisfied!"""
                 % ("debug" if python_debug else "development", candidates)
             )
 
+    if python_version >= (3, 13):
+        yield os.path.join(candidate, "internal", "mimalloc")
+
     if env.self_compiled_python_uninstalled:
         yield python_prefix_external
 
@@ -908,9 +916,32 @@ def discoverSourceFiles():
 
 source_files = discoverSourceFiles()
 
+# Remove the target file to avoid cases where it falsely doesn't get rebuild
+# and then lingers from previous builds,
+deleteFile(result_exe, must_exist=False)
+
+# Workaround for MinGW64 not supporting unicode result paths for "-o" basename.
+if os.name == "nt" and not isFilesystemEncodable(result_exe):
+    result_exe = os.path.join(
+        os.path.dirname(result_exe),
+        "_nuitka_temp.pyd" if module_mode else "_nuitka_temp.exe",
+    )
+
+    deleteFile(result_exe, must_exist=False)
+
 if module_mode:
-    # For Python modules, the standard shared library extension is not what
-    # gets used. spell-checker: ignore SHLIBSUFFIX
+    # For Python modules, the standard shared library extension is not what gets
+    # used. spell-checker: ignore SHLIBSUFFIX
+    module_suffix = getFilenameExtension(result_exe)
+    result_base_path = changeFilenameExtension(result_exe, "")
+
+    extra_suffix = getFilenameExtension(result_base_path)
+    if extra_suffix != "":
+        module_suffix = extra_suffix + module_suffix
+        result_base_path = changeFilenameExtension(result_base_path, "")
+
+    assert getFilenameExtension(result_base_path) == "", result_base_path
+
     env["SHLIBSUFFIX"] = module_suffix
 
     target = env.SharedLibrary(
@@ -922,10 +953,6 @@ else:
 # Use compiler/linker flags provided via environment variables
 importEnvironmentVariableSettings(env)
 
-# Remove the target file to avoid cases where it falsely doesn't get rebuild
-# and then lingers from previous builds,
-if os.path.exists(target[0].abspath):
-    os.unlink(target[0].abspath)
 
 if job_count:
     scons_details_logger.info("Told to run compilation on %d CPUs." % job_count)
@@ -1059,7 +1086,7 @@ if env.msvc_mode and not disable_ccache:
         source_dir=source_dir,
     )
 
-writeSconsReport(env)
+writeSconsReport(env=env, target=target)
 
 setSconsProgressBarTotal(name=env.progressbar_name, total=len(source_files))
 

nuitka/build/CCompilerVersion.scons

@@ -87,8 +87,8 @@ experimental = getArgumentList("experimental", "")
 # good with the compiler in question.
 lto_mode = getArgumentDefaulted("lto_mode", "auto")
 
-# Windows subsystem mode: Disable console for windows builds.
-disable_console = getArgumentBool("disable_console", False)
+# Console mode specified
+console_mode = getArgumentDefaulted("console_mode", "attach")
 
 # Unstripped mode: Do not remove debug symbols.
 unstripped_mode = getArgumentBool("unstripped_mode", False)
@@ -207,7 +207,7 @@ env.the_compiler = env["CC"] or env["CXX"]
 env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
-env.disable_console = disable_console
+env.console_mode = console_mode
 env.nuitka_src = nuitka_src
 env.low_memory = False
 env.macos_min_version = macos_min_version

nuitka/build/Onefile.scons

@@ -126,8 +126,8 @@ trace_mode = getArgumentBool("trace_mode", False)
 # good with the compiler in question.
 lto_mode = getArgumentDefaulted("lto_mode", "auto")
 
-# Windows subsystem mode: Disable console for windows builds.
-disable_console = getArgumentBool("disable_console", False)
+# Console mode specified
+console_mode = getArgumentDefaulted("console_mode", "attach")
 
 # Unstripped mode: Do not remove debug symbols.
 unstripped_mode = getArgumentBool("unstripped_mode", False)
@@ -265,7 +265,7 @@ env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.standalone_mode = True  # We are only used in this case.
 env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
-env.disable_console = disable_console
+env.console_mode = console_mode
 env.source_dir = source_dir
 env.nuitka_src = nuitka_src
 env.low_memory = False  # Never a concern in this case.
@@ -537,7 +537,7 @@ if env.gcc_mode:
         env=env,
     )
 
-writeSconsReport(env)
+writeSconsReport(env=env, target=target)
 
 setSconsProgressBarTotal(name="Onefile", total=len(source_files))
 

nuitka/build/SconsCaching.py

@@ -143,8 +143,9 @@ def enableCcache(
 
     if inject_ccache:
         # The ccache needs absolute path, otherwise it will not work.
-        ccache_logfile = os.path.abspath(
-            os.path.join(source_dir, "ccache-%d.txt" % os.getpid())
+        ccache_logfile = getExternalUsePath(
+            os.path.abspath(os.path.join(source_dir, "ccache-%d.txt" % os.getpid())),
+            only_dirname=True,
         )
 
         setEnvironmentVariable(env, "CCACHE_LOGFILE", ccache_logfile)

nuitka/build/SconsCompilerSettings.py

@@ -637,7 +637,7 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
         # Don't export anything by default, this should create smaller executables.
         env.Append(CCFLAGS=["-fvisibility=hidden", "-fvisibility-inlines-hidden"])
 
-        if env.debug_mode:
+        if env.debug_mode and "allow-c-warnings" not in env.experimental_flags:
             env.Append(CCFLAGS=["-Wunused-but-set-variable"])
 
     # Support for macOS standalone to run on older OS versions.
@@ -780,12 +780,18 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
         if not env.clang_mode:
             env.Append(LINKFLAGS=["-Wl,--enable-auto-import"])
 
-        if env.disable_console:
+    # Even if console is forced, for Win32 it means to specify Windows
+    # subsystem, we can still attach or create.
+    if env.console_mode != "force":
+        if env.mingw_mode:
             env.Append(LINKFLAGS=["-Wl,--subsystem,windows"])
-
-    if env.mingw_mode or env.msvc_mode:
-        if env.disable_console:
             env.Append(CPPDEFINES=["_NUITKA_WINMAIN_ENTRY_POINT"])
+        elif env.msvc_mode:
+            env.Append(LINKFLAGS=["/SUBSYSTEM:windows"])
+            env.Append(CPPDEFINES=["_NUITKA_WINMAIN_ENTRY_POINT"])
+
+    if env.console_mode == "attach" and os.name == "nt":
+        env.Append(CPPDEFINES=["_NUITKA_ATTACH_CONSOLE_WINDOW"])
 
     # Avoid dependency on MinGW libraries, spell-checker: ignore libgcc
     if env.mingw_mode and not env.clang_mode:
@@ -984,9 +990,15 @@ def reportCCompiler(env, context, output_func):
             ".".join(str(d) for d in env.gcc_version),
         )
     elif isClangName(env.the_cc_name):
+        clang_version = myDetectVersion(env, env.the_cc_name)
+        if clang_version is None:
+            clang_version = "not found"
+        else:
+            clang_version = ".".join(str(d) for d in clang_version)
+
         cc_output = "%s %s" % (
             env.the_cc_name,
-            ".".join(str(d) for d in myDetectVersion(env, env.the_cc_name)),
+            clang_version,
         )
     else:
         cc_output = env.the_cc_name

nuitka/build/SconsInterface.py

@@ -17,7 +17,11 @@ import sys
 from nuitka import Options, Tracing
 from nuitka.__past__ import unicode
 from nuitka.containers.OrderedDicts import OrderedDict
-from nuitka.Options import getOnefileChildGraceTime, isOnefileMode
+from nuitka.Options import (
+    getOnefileChildGraceTime,
+    isExperimental,
+    isOnefileMode,
+)
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonFlavors import (
     isAnacondaPython,
@@ -37,6 +41,7 @@ from nuitka.utils.Execution import (
     withEnvironmentVarsOverridden,
 )
 from nuitka.utils.FileOperations import (
+    areSamePaths,
     changeFilenameExtension,
     deleteFile,
     getDirectoryRealPath,
@@ -46,6 +51,7 @@ from nuitka.utils.FileOperations import (
     listDir,
     makePath,
     putTextFileContents,
+    renameFile,
     withDirectoryChange,
 )
 from nuitka.utils.InstalledPythons import findInstalledPython
@@ -58,7 +64,7 @@ from nuitka.utils.Utils import (
 )
 
 from .SconsCaching import checkCachingSuccess
-from .SconsUtils import flushSconsReports
+from .SconsUtils import flushSconsReports, getSconsReportValue
 
 
 def getSconsDataPath():
@@ -82,7 +88,7 @@ def _getSconsBinaryCall():
 
     inline_path = os.path.join(_getSconsInlinePath(), "bin", "scons.py")
 
-    if os.path.exists(inline_path):
+    if os.path.exists(inline_path) and not isExperimental("force-system-scons"):
         return [
             _getPythonForSconsExePath(),
             "-W",
@@ -336,10 +342,9 @@ def runScons(options, env_values, scons_filename):
             options = copy.deepcopy(options)
             source_dir = options["source_dir"]
             options["source_dir"] = "."
-            options["result_name"] = getExternalUsePath(
-                options["result_name"], only_dirname=True
-            )
             options["nuitka_src"] = getExternalUsePath(options["nuitka_src"])
+
+            orig_result_exe = options.get("result_exe")
             if "result_exe" in options:
                 options["result_exe"] = getExternalUsePath(
                     options["result_exe"], only_dirname=True
@@ -370,6 +375,7 @@ def runScons(options, env_values, scons_filename):
                     source_dir=source_dir, scons_command=scons_command
                 )
 
+                source_dir = getExternalUsePath(source_dir)
             try:
                 result = subprocess.call(scons_command, shell=False, cwd=source_dir)
             except KeyboardInterrupt:
@@ -380,6 +386,20 @@ def runScons(options, env_values, scons_filename):
         flushSconsReports()
 
         if "source_dir" in options and result == 0:
+            if "result_exe" in options:
+                scons_created_exe = getSconsReportValue(
+                    source_dir or options["source_dir"], "TARGET"
+                )
+
+                if not os.path.exists(scons_created_exe):
+                    Tracing.scons_logger.sysexit(
+                        "Error, scons failed to create the expected file %r. "
+                        % scons_created_exe
+                    )
+
+                if not areSamePaths(options["result_exe"], scons_created_exe):
+                    renameFile(scons_created_exe, orig_result_exe)
+
             checkCachingSuccess(source_dir or options["source_dir"])
 
         return result == 0
@@ -475,8 +495,8 @@ def setCommonSconsOptions(options):
     if Options.shallDisableCCacheUsage():
         options["disable_ccache"] = asBoolStr(True)
 
-    if Options.shallDisableConsoleWindow() and Options.mayDisableConsoleWindow():
-        options["disable_console"] = asBoolStr(True)
+    if isWin32Windows() and Options.getWindowsConsoleMode() != "attach":
+        options["console_mode"] = Options.getWindowsConsoleMode()
 
     if Options.getLtoMode() != "auto":
         options["lto_mode"] = Options.getLtoMode()

nuitka/build/SconsUtils.py

@@ -18,7 +18,9 @@ from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Execution import executeProcess
 from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
     getFileContentByLine,
+    getFilenameExtension,
     getWindowsShortPathName,
     hasFilenameExtension,
     isFilesystemEncodable,
@@ -359,7 +361,7 @@ def addToPATH(env, dirname, prefix):
     setEnvironmentVariable(env, "PATH", os.pathsep.join(path_value))
 
 
-def writeSconsReport(env):
+def writeSconsReport(env, target):
     with openTextFile(
         _getSconsReportFilename(env.source_dir), "w", encoding="utf8"
     ) as report_file:
@@ -390,6 +392,7 @@ def writeSconsReport(env):
         print("clangcl_mode=%s" % env.clangcl_mode, file=report_file)
 
         print("PATH=%s" % os.environ["PATH"], file=report_file)
+        print("TARGET=%s" % target[0].abspath, file=report_file)
 
 
 def reportSconsUnexpectedOutput(env, cmdline, stdout, stderr):
@@ -624,6 +627,11 @@ def scanSourceDir(env, dirname, plugins):
         if isWin32Windows() and not isFilesystemEncodable(filename_base):
             target_filename = getWindowsShortPathName(target_filename)
 
+            # Avoid ".C" suffixes, that MinGW64 wouldn't recognize.
+            target_filename = changeFilenameExtension(
+                target_filename, getFilenameExtension(target_filename).lower()
+            )
+
         # We pretend to use C++ if no C11 compiler is present.
         if env.c11_mode:
             yield target_filename

nuitka/build/include/nuitka/allocator.h

@@ -13,6 +13,39 @@
 #define _PyObject_GC_IS_TRACKED(obj) (1)
 #endif
 
+// The full API is available for Python 3.5 only
+#if PYTHON_VERSION >= 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+extern void *(*python_obj_malloc)(void *ctx, size_t size);
+extern void *(*python_mem_malloc)(void *ctx, size_t size);
+extern void *(*python_mem_calloc)(void *ctx, size_t nelem, size_t elsize);
+
+#if defined(Py_DEBUG)
+extern void *python_obj_ctx;
+extern void *python_mem_ctx;
+#else
+#define python_obj_ctx (NULL)
+#define python_mem_ctx (NULL)
+#endif
+
+extern void initNuitkaAllocators(void);
+
+// Our version of "PyObject_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaObject_Malloc(size_t size) { return python_obj_malloc(python_obj_ctx, size); }
+
+// Our version of "PyMem_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Malloc(size_t size) { return python_mem_malloc(python_mem_ctx, size); }
+
+// Our version of "PyMem_Calloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Calloc(size_t nelem, size_t elsize) {
+    return python_mem_calloc(python_mem_ctx, nelem, elsize);
+}
+
+#else
+#define NuitkaObject_Malloc(size) PyObject_MALLOC(size)
+#define NuitkaMem_Malloc(size) PyMem_MALLOC(size)
+#define NuitkaMem_Calloc(elem, elsize) PyMem_CALLOC(elem, elsize)
+#endif
+
 #if PYTHON_VERSION >= 0x380 && PYTHON_VERSION < 0x3c0
 // Need to make Py_DECREF a macro again that doesn't call an API
 static inline void _Nuitka_Py_DECREF(PyObject *ob) {
@@ -71,6 +104,18 @@ static inline void _Nuitka_Py_XDECREF(PyObject *ob) {
 
 #endif
 
+// For Python3.12, avoid reference management if value is known to be immortal.
+#if PYTHON_VERSION < 0x3c0
+#define Py_INCREF_IMMORTAL(value) Py_INCREF(value)
+#define Py_DECREF_IMMORTAL(value) Py_DECREF(value)
+#elif defined(__NUITKA_NO_ASSERT__)
+#define Py_INCREF_IMMORTAL(value)
+#define Py_DECREF_IMMORTAL(value)
+#else
+#define Py_INCREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#define Py_DECREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#endif
+
 // Macro introduced with Python3.9 or higher, make it generally available.
 #ifndef Py_SET_TYPE
 static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type = type; }
@@ -116,7 +161,7 @@ static PyObject *Nuitka_PyType_AllocNoTrackVar(PyTypeObject *type, Py_ssize_t ni
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
     assert(pre_size == sizeof(PyGC_Head));
 
-    char *alloc = (char *)PyObject_Malloc(size + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(size + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -151,7 +196,7 @@ static PyObject *Nuitka_PyType_AllocNoTrack(PyTypeObject *type) {
     // TODO: This ought to be static for all our types, so remove it as a call.
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
 
-    char *alloc = (char *)PyObject_Malloc(_PyObject_SIZE(type) + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(_PyObject_SIZE(type) + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -229,6 +274,17 @@ NUITKA_MAY_BE_UNUSED static void *Nuitka_GC_New(PyTypeObject *type) {
     return op;
 }
 
+static bool inline Nuitka_GC_IS_TRACKED_X(PyObject *object) {
+    return object == NULL || _PyObject_GC_IS_TRACKED(object);
+}
+
+// To allow us marking some of our own values as immortal.
+#if PYTHON_VERSION >= 0x3c0
+static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) { object->ob_refcnt = _Py_IMMORTAL_REFCNT; }
+#else
+#define Py_SET_REFCNT_IMMORTAL(object)
+#endif
+
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/include/nuitka/compiled_frame.h

@@ -90,11 +90,27 @@ NUITKA_MAY_BE_UNUSED static inline bool isFakeCodeObject(PyCodeObject *code) {
 
 extern PyTypeObject Nuitka_Frame_Type;
 
-static inline bool Nuitka_Frame_Check(PyObject *object) {
+static inline bool Nuitka_Frame_CheckExact(PyObject *object) {
     CHECK_OBJECT(object);
     return Py_TYPE(object) == &Nuitka_Frame_Type;
 }
 
+static inline bool Nuitka_Frame_Check(PyObject *object) {
+    assert(object);
+
+    if (!_PyObject_GC_IS_TRACKED(object)) {
+        return false;
+    }
+
+    CHECK_OBJECT(object);
+
+    if (Nuitka_Frame_CheckExact(object)) {
+        return true;
+    }
+
+    return strcmp(Py_TYPE(object)->tp_name, "compiled_frame") == 0;
+}
+
 struct Nuitka_FrameObject {
     PyFrameObject m_frame;
 
@@ -154,10 +170,20 @@ extern int count_hit_frame_cache_instances;
 extern void dumpFrameStack(void);
 #endif
 
+#if PYTHON_VERSION >= 0x3b0
+inline static PyCodeObject *Nuitka_InterpreterFrame_GetCodeObject(_PyInterpreterFrame *frame) {
+#if PYTHON_VERSION < 0x3d0
+    return frame->f_code;
+#else
+    return (PyCodeObject *)frame->f_executable;
+#endif
+}
+#endif
+
 inline static PyCodeObject *Nuitka_Frame_GetCodeObject(PyFrameObject *frame) {
 #if PYTHON_VERSION >= 0x3b0
     assert(frame->f_frame);
-    return frame->f_frame->f_code;
+    return Nuitka_InterpreterFrame_GetCodeObject(frame->f_frame);
 #else
     return frame->f_code;
 #endif
@@ -168,6 +194,7 @@ inline static void assertPythonFrameObject(PyFrameObject *frame_object) {
     // TODO: Need to do this manually, as this is making frame caching code
     // vulnerable to mistakes, but so far the compiled frame type is private
     // assert(PyObject_IsInstance((PyObject *)frame_object, (PyObject *)&PyFrame_Type));
+    CHECK_OBJECT(frame_object);
 
     CHECK_CODE_OBJECT(Nuitka_Frame_GetCodeObject(frame_object));
 }
@@ -256,14 +283,23 @@ static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *frame) {
 #endif
 
 #if PYTHON_VERSION >= 0x3b0
+
+#if PYTHON_VERSION < 0x3d0
+#define CURRENT_TSTATE_INTERPRETER_FRAME(tstate) tstate->cframe->current_frame
+#else
+#define CURRENT_TSTATE_INTERPRETER_FRAME(tstate) tstate->current_frame
+#endif
+
 NUITKA_MAY_BE_UNUSED inline static void pushFrameStackInterpreterFrame(PyThreadState *tstate,
                                                                        _PyInterpreterFrame *interpreter_frame) {
-    _PyInterpreterFrame *old = tstate->cframe->current_frame;
+    _PyInterpreterFrame *old = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
     interpreter_frame->previous = old;
-    tstate->cframe->current_frame = interpreter_frame;
+    CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = interpreter_frame;
 
-    if (old != NULL && interpreter_frame->frame_obj) {
+    if (old != NULL && !_PyFrame_IsIncomplete(old) && interpreter_frame->frame_obj) {
         interpreter_frame->frame_obj->f_back = old->frame_obj;
+        CHECK_OBJECT_X(old->frame_obj);
+
         Py_XINCREF(old->frame_obj);
     }
 }
@@ -281,7 +317,7 @@ NUITKA_MAY_BE_UNUSED inline static void pushFrameStackPythonFrame(PyThreadState
 
     if (old) {
         assertPythonFrameObject(old);
-        CHECK_CODE_OBJECT(old->f_code);
+        CHECK_CODE_OBJECT(Nuitka_Frame_GetCodeObject(old));
     }
 
     // No recursion with identical frames allowed, assert against it.
@@ -292,7 +328,6 @@ NUITKA_MAY_BE_UNUSED inline static void pushFrameStackPythonFrame(PyThreadState
 
     // Transfer ownership of old frame.
     if (old != NULL) {
-
         frame_object->f_back = old;
     }
 
@@ -336,13 +371,13 @@ NUITKA_MAY_BE_UNUSED inline static void popFrameStack(PyThreadState *tstate) {
     Nuitka_Frame_MarkAsNotExecuting(frame_object);
     Py_DECREF(frame_object);
 #else
-    assert(tstate->cframe);
-    assert(tstate->cframe->current_frame);
+    assert(CURRENT_TSTATE_INTERPRETER_FRAME(tstate));
 
-    struct Nuitka_FrameObject *frame_object = (struct Nuitka_FrameObject *)tstate->cframe->current_frame->frame_obj;
+    struct Nuitka_FrameObject *frame_object =
+        (struct Nuitka_FrameObject *)CURRENT_TSTATE_INTERPRETER_FRAME(tstate)->frame_obj;
     CHECK_OBJECT(frame_object);
 
-    tstate->cframe->current_frame = tstate->cframe->current_frame->previous;
+    CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = CURRENT_TSTATE_INTERPRETER_FRAME(tstate)->previous;
 
     Nuitka_Frame_MarkAsNotExecuting(frame_object);
 
@@ -389,7 +424,7 @@ NUITKA_MAY_BE_UNUSED static PyCodeObject *Nuitka_GetFrameCodeObject(struct Nuitk
 #if PYTHON_VERSION < 0x3b0
     return nuitka_frame->m_frame.f_code;
 #else
-    return nuitka_frame->m_interpreter_frame.f_code;
+    return Nuitka_InterpreterFrame_GetCodeObject(&nuitka_frame->m_interpreter_frame);
 #endif
 }
 
@@ -415,7 +450,7 @@ NUITKA_MAY_BE_UNUSED static Nuitka_ThreadStateFrameType *_Nuitka_GetThreadStateF
 #if PYTHON_VERSION < 0x3b0
     return tstate->frame;
 #else
-    return tstate->cframe->current_frame;
+    return CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
 #endif
 }
 

nuitka/build/include/nuitka/compiled_function.h

@@ -71,6 +71,10 @@ struct Nuitka_FunctionObject {
     PyObject *m_qualname;
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+    PyObject *m_type_params;
+#endif
+
     // Constant return value to use.
     PyObject *m_constant_return_value;
 

nuitka/build/include/nuitka/constants.h

@@ -91,6 +91,8 @@ extern PyObject **global_constants;
 #define const_str_plain_open global_constants[30]
 // 'keys'
 #define const_str_plain_keys global_constants[30]
+// 'get'
+#define const_str_plain_get global_constants[30]
 // 'as_file'
 #define const_str_plain_as_file global_constants[30]
 // 'register'
@@ -115,6 +117,10 @@ extern PyObject **global_constants;
 #define const_str_plain_classmethod global_constants[36]
 // 'name'
 #define const_str_plain_name global_constants[37]
+// 'ascii'
+#define const_str_plain_ascii global_constants[37]
+// 'punycode'
+#define const_str_plain_punycode global_constants[37]
 // 'globals'
 #define const_str_plain_globals global_constants[38]
 // 'locals'