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

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -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
+
 // This implements the loading of C compiled modules and shared library
 // extension modules bundled for standalone mode.
 
@@ -37,6 +22,9 @@
 #ifdef _WIN32
 #undef SEP
 #define SEP '\\'
+#define SEP_L L'\\'
+#else
+#define SEP_L SEP
 #endif
 
 #ifdef _WIN32
@@ -64,7 +52,7 @@ static inline bool isVerbose(void) { return false; }
 static struct Nuitka_MetaPathBasedLoaderEntry *loader_entries = NULL;
 
 static bool hasFrozenModule(char const *name) {
-    for (struct _frozen const *p = PyImport_FrozenModules;; p++) {
+    for (struct _frozen const *p = PyImport_FrozenModules; p != NULL; p++) {
         if (p->name == NULL) {
             return false;
         }
@@ -77,10 +65,11 @@ static bool hasFrozenModule(char const *name) {
     return true;
 }
 
-static char *appendModulenameAsPath(char *buffer, char const *module_name, size_t buffer_size) {
+static char *appendModuleNameAsPath(char *buffer, char const *module_name, size_t buffer_size) {
     // Skip to the end
     while (*buffer != 0) {
         buffer++;
+        buffer_size -= 1;
     }
 
     while (*module_name) {
@@ -105,20 +94,17 @@ static char *appendModulenameAsPath(char *buffer, char const *module_name, size_
 
 #if defined(_WIN32) && defined(_NUITKA_STANDALONE)
 
-static void appendModulenameAsPathW(wchar_t *buffer, char const *module_name, size_t buffer_size) {
-    // Skip to the end
-    while (*buffer != 0) {
-        buffer++;
-    }
+static void appendModuleNameAsPathW(wchar_t *buffer, PyObject *module_name, size_t buffer_size) {
+    wchar_t const *module_name_wstr = PyUnicode_AsWideCharString(module_name, NULL);
 
-    while (*module_name) {
-        char c = *module_name++;
+    while (*module_name_wstr != 0) {
+        wchar_t c = *module_name_wstr++;
 
-        if (c == '.') {
-            c = SEP;
+        if (c == L'.') {
+            c = SEP_L;
         }
 
-        appendCharSafeW(buffer, c, buffer_size);
+        appendWCharSafeW(buffer, c, buffer_size);
     }
 }
 #endif
@@ -150,7 +136,7 @@ static void patchCodeObjectPaths(PyCodeObject *code_object, PyObject *module_pat
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_RELATIVE_PATH_FROM_NAME(char const *name, bool is_package, bool dir_only) {
     char buffer[MAXPATHLEN + 1] = {0};
 
-    appendModulenameAsPath(buffer, name, sizeof(buffer));
+    appendModuleNameAsPath(buffer, name, sizeof(buffer));
 
     if (dir_only == false) {
         if (is_package) {
@@ -180,19 +166,35 @@ NUITKA_MAY_BE_UNUSED static PyObject *MAKE_RELATIVE_PATH_FROM_NAME(char const *n
     return result;
 }
 
-static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_object, char const *name,
-                                          bool is_package) {
+static PyObject *_makeDunderPathObject(PyThreadState *tstate, PyObject *module_path_entry) {
+    CHECK_OBJECT(module_path_entry);
+
+    PyObject *path_list = MAKE_LIST_EMPTY(tstate, 1);
+    if (unlikely(path_list == NULL)) {
+        return NULL;
+    }
+
+    PyList_SET_ITEM0(path_list, 0, module_path_entry);
+
+    CHECK_OBJECT(path_list);
+    return path_list;
+}
+
+static PyObject *loadModuleFromCodeObject(PyThreadState *tstate, PyObject *module, PyCodeObject *code_object,
+                                          char const *name, bool is_package) {
     assert(code_object != NULL);
 
-    bool b_res = Nuitka_SetModuleString(name, module);
-    assert(b_res != false);
+    {
+        NUITKA_MAY_BE_UNUSED bool b_res = Nuitka_SetModuleString(name, module);
+        assert(b_res != false);
+    }
 
     char buffer[MAXPATHLEN + 1] = {0};
 
     PyObject *module_path_entry = NULL;
 
     if (is_package) {
-        appendModulenameAsPath(buffer, name, sizeof(buffer));
+        appendModuleNameAsPath(buffer, name, sizeof(buffer));
         PyObject *module_path_entry_base = Nuitka_String_FromString(buffer);
 
         module_path_entry = MAKE_RELATIVE_PATH(module_path_entry_base);
@@ -201,7 +203,7 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
         appendCharSafe(buffer, SEP, sizeof(buffer));
         appendStringSafe(buffer, "__init__.py", sizeof(buffer));
     } else {
-        appendModulenameAsPath(buffer, name, sizeof(buffer));
+        appendModuleNameAsPath(buffer, name, sizeof(buffer));
         appendStringSafe(buffer, ".py", sizeof(buffer));
     }
 
@@ -212,17 +214,9 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
 
     if (is_package) {
         /* Set __path__ properly, unlike frozen module importer does. */
-        PyObject *path_list = MAKE_LIST_EMPTY(1);
-        if (unlikely(path_list == NULL))
-            return NULL;
-
-        int res = PyList_SetItem(path_list, 0, module_path_entry);
-        if (unlikely(res != 0)) {
-            return NULL;
-        }
-        Py_INCREF(module_path_entry);
+        PyObject *path_list = _makeDunderPathObject(tstate, module_path_entry);
 
-        res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
+        int res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
         if (unlikely(res != 0)) {
             return NULL;
         }
@@ -258,7 +252,7 @@ static struct Nuitka_MetaPathBasedLoaderEntry *findEntry(char const *name) {
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -286,7 +280,7 @@ static struct Nuitka_MetaPathBasedLoaderEntry *findContainingPackageEntry(char c
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -325,7 +319,7 @@ static PyObject *_getImportingSuffixesByPriority(PyThreadState *tstate, int kind
     static PyObject *result = NULL;
 
     if (result == NULL) {
-        result = MAKE_LIST_EMPTY(0);
+        result = MAKE_LIST_EMPTY(tstate, 0);
 
         PyObject *imp_module = PyImport_ImportModule("imp");
         PyObject *get_suffixes_func = PyObject_GetAttrString(imp_module, "get_suffixes");
@@ -383,10 +377,10 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
         return false;
     }
 
-    PyObject *candidates = MAKE_LIST_EMPTY(0);
+    PyObject *candidates = MAKE_LIST_EMPTY(tstate, 0);
 
     // Search only relative to the parent name of course.
-    char const *module_relname_str = Nuitka_String_AsString(module_name) + strlen(parent_module_name) + 1;
+    char const *module_relative_name_str = Nuitka_String_AsString(module_name) + strlen(parent_module_name) + 1;
 
     Py_ssize_t parent_path_size = PyList_GET_SIZE(parent_path);
 
@@ -408,8 +402,8 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
             if (Nuitka_String_CheckExact(filename)) {
                 char const *filename_str = Nuitka_String_AsString(filename);
 
-                if (strncmp(filename_str, module_relname_str, strlen(module_relname_str)) == 0 &&
-                    filename_str[strlen(module_relname_str)] == '.') {
+                if (strncmp(filename_str, module_relative_name_str, strlen(module_relative_name_str)) == 0 &&
+                    filename_str[strlen(module_relative_name_str)] == '.') {
                     LIST_APPEND1(candidates, PyTuple_Pack(2, path_element, filename));
                 }
             }
@@ -419,7 +413,7 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
 #if 0
     PRINT_STRING("CANDIDATES:");
     PRINT_STRING(Nuitka_String_AsString(module_name));
-    PRINT_STRING(module_relname_str);
+    PRINT_STRING(module_relative_name_str);
     PRINT_ITEM(candidates);
     PRINT_NEW_LINE();
 #endif
@@ -442,11 +436,11 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
 
             char const *candidate_str = Nuitka_String_AsString(candidate);
 
-            if (strcmp(suffix_str, candidate_str + strlen(module_relname_str)) == 0) {
+            if (strcmp(suffix_str, candidate_str + strlen(module_relative_name_str)) == 0) {
                 PyObject *fullpath = JOIN_PATH2(directory, candidate);
 
                 if (installed_extension_modules == NULL) {
-                    installed_extension_modules = MAKE_DICT_EMPTY();
+                    installed_extension_modules = MAKE_DICT_EMPTY(tstate);
                 }
 
 // Force path to unicode, to have easier consumption, as we need a wchar_t or char *
@@ -470,11 +464,8 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
     return result;
 }
 
-#ifdef _WIN32
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const wchar_t *filename);
-#else
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const char *filename);
-#endif
+static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename,
+                                         bool is_package);
 
 static PyObject *callIntoInstalledExtensionModule(PyThreadState *tstate, PyObject *module_name,
                                                   PyObject *extension_module_filename) {
@@ -492,7 +483,9 @@ static PyObject *callIntoInstalledExtensionModule(PyThreadState *tstate, PyObjec
     char const *extension_module_filename_str = Nuitka_String_AsString(extension_module_filename);
 #endif
 
-    return callIntoExtensionModule(tstate, Nuitka_String_AsString(module_name), extension_module_filename_str);
+    // TODO: The value of "is_package" is guessed, maybe infer from filename being
+    // a "__init__.so" and the like.
+    return callIntoExtensionModule(tstate, Nuitka_String_AsString(module_name), extension_module_filename_str, false);
 }
 
 #endif
@@ -573,7 +566,7 @@ static PyObject *_nuitka_loader_find_module(PyObject *self, PyObject *args, PyOb
         PySys_WriteStderr("import %s # denied responsibility\n", name);
     }
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -593,37 +586,18 @@ static PyObject *_nuitka_loader_get_data(PyObject *self, PyObject *args, PyObjec
     return GET_FILE_BYTES(tstate, filename);
 }
 
-#ifdef _WIN32
-static void setModuleFileValue(PyThreadState *tstate, PyObject *module, wchar_t const *filename) {
-#else
-static void setModuleFileValue(PyThreadState *tstate, PyObject *module, char const *filename) {
-#endif
-    bool needs_update = false;
-
-    PyObject *existing_file_value = LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__);
+static void setModuleFileValue(PyThreadState *tstate, PyObject *module, filename_char_t const *filename) {
+    CHECK_OBJECT(module);
+    assert(filename != NULL);
 
-    if (existing_file_value == NULL) {
-        CLEAR_ERROR_OCCURRED(tstate);
-        needs_update = true;
-    } else {
-        if (existing_file_value == Py_None) {
-            needs_update = true;
-        }
+    assert(PyModule_Check(module));
 
-        Py_DECREF(existing_file_value);
-    }
+    PyObject *dict = PyModule_GetDict(module);
 
-    if (needs_update) {
-#ifdef _WIN32
-        int res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, NuitkaUnicode_FromWideChar(filename, -1));
-#else
-        int res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, PyUnicode_FromString(filename));
-#endif
-        if (unlikely(res < 0)) {
-            // Might be refuted, which wouldn't be harmful.
-            CLEAR_ERROR_OCCURRED(tstate);
-        }
-    }
+    // TODO: We should have DICT_SET_ITEM0/1 for these things.
+    PyObject *new_file_value = Nuitka_String_FromFilename(filename);
+    DICT_SET_ITEM(dict, const_str_plain___file__, new_file_value);
+    Py_DECREF(new_file_value);
 }
 
 #if PYTHON_VERSION < 0x300
@@ -641,11 +615,99 @@ typedef PyObject *(*entrypoint_t)(void);
 static PyObject *createModuleSpec(PyThreadState *tstate, PyObject *module_name, PyObject *origin, bool is_package);
 #endif
 
+static void _fillExtensionModuleDllEntryFunctionName(PyThreadState *tstate, char *buffer, size_t buffer_size,
+                                                     char const *name) {
+
+#if PYTHON_VERSION >= 0x350
+    PyObject *name_bytes_obj = PyBytes_FromString(name);
+    PyObject *name_obj = BYTES_DECODE2(tstate, name_bytes_obj, Nuitka_String_FromString("utf8"));
+    Py_DECREF(name_bytes_obj);
+
+    PyObject *name_ascii = UNICODE_ENCODE2(tstate, name_obj, const_str_plain_ascii);
+
+    if (name_ascii == NULL) {
+        DROP_ERROR_OCCURRED(tstate);
+
+        PyObject *name_punycode = UNICODE_ENCODE2(tstate, name_obj, const_str_plain_punycode);
+
+        CHECK_OBJECT(name_punycode);
+
+        snprintf(buffer, buffer_size, "PyInitU_%s", PyBytes_AsString(name_punycode));
+
+        Py_DECREF(name_punycode);
+    } else {
+        Py_DECREF(name_ascii);
+
+        snprintf(buffer, buffer_size, "PyInit_%s", name);
+    }
+    Py_DECREF(name_obj);
+#else
+
+    snprintf(buffer, buffer_size,
+#if PYTHON_VERSION < 0x300
+             "init%s",
+#else
+             "PyInit_%s",
+#endif
+             name);
+#endif
+}
+
+#ifdef _NUITKA_STANDALONE
+// Append the the entry name from full path module name with dots,
+// and translate these into directory separators.
+static void _makeModuleCFilenameValue(filename_char_t *filename, size_t filename_size, char const *module_name_cstr,
+                                      PyObject *module_name, bool is_package) {
 #ifdef _WIN32
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const wchar_t *filename) {
+    appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), filename_size);
+    appendWCharSafeW(filename, SEP_L, filename_size);
+    appendModuleNameAsPathW(filename, module_name, filename_size);
+    if (is_package) {
+        appendWCharSafeW(filename, SEP_L, filename_size);
+        appendStringSafeW(filename, "__init__", filename_size);
+    }
+    appendStringSafeW(filename, ".pyd", filename_size);
 #else
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const char *filename) {
+    appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), filename_size);
+    appendCharSafe(filename, SEP, filename_size);
+    appendModuleNameAsPath(filename, module_name_cstr, filename_size);
+    if (is_package) {
+        appendCharSafe(filename, SEP, filename_size);
+        appendStringSafe(filename, "__init__", filename_size);
+    }
+    appendStringSafe(filename, ".so", filename_size);
 #endif
+}
+#endif
+
+#if PYTHON_VERSION >= 0x3c0 && defined(_NUITKA_USE_UNEXPOSED_API)
+extern _Thread_local const char *pkgcontext;
+#endif
+
+static const char *NuitkaImport_SwapPackageContext(const char *new_context) {
+// TODO: The locking APIs for 3.13 give errors here that are not explained
+// yet.
+#if PYTHON_VERSION >= 0x3c0 && PYTHON_VERSION < 0x3d0
+    // spell-checker: ignore pkgcontext
+    const char *old_context = _PyRuntime.imports.pkgcontext;
+    _PyRuntime.imports.pkgcontext = new_context;
+#if PYTHON_VERSION >= 0x3c0 && defined(_NUITKA_USE_UNEXPOSED_API)
+    pkgcontext = new_context;
+#endif
+    return old_context;
+#elif PYTHON_VERSION >= 0x370
+    char const *old_context = _Py_PackageContext;
+    _Py_PackageContext = (char *)new_context;
+    return old_context;
+#else
+    char *old_context = _Py_PackageContext;
+    _Py_PackageContext = (char *)new_context;
+    return (char const *)old_context;
+#endif
+}
+
+static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename,
+                                         bool is_package) {
     // Determine the package name and basename of the module to load.
     char const *dot = strrchr(full_name, '.');
     char const *name;
@@ -661,13 +723,7 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     }
 
     char entry_function_name[1024];
-    snprintf(entry_function_name, sizeof(entry_function_name),
-#if PYTHON_VERSION < 0x300
-             "init%s",
-#else
-             "PyInit_%s",
-#endif
-             name);
+    _fillExtensionModuleDllEntryFunctionName(tstate, entry_function_name, sizeof(entry_function_name), name);
 
 #ifdef _WIN32
     if (isVerbose()) {
@@ -675,6 +731,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     }
 
 #ifndef _NUITKA_EXPERIMENTAL_DEBUG_STANDALONE
+    // Disable all but critical errors, prevents dialogs from showing.
+    // spell-checker: ignore SEM_FAILCRITICALERRORS
     unsigned int old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
 #endif
 
@@ -704,15 +762,18 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 
         // Report either way even if failed to get error message.
         if (size == 0) {
-            PyOS_snprintf(buffer, sizeof(buffer), "LoadLibraryExW '%S' failed with error code %d", filename,
-                          error_code);
+            int ret = PyOS_snprintf(buffer, sizeof(buffer), "LoadLibraryExW '%S' failed with error code %d", filename,
+                                    error_code);
+
+            assert(ret >= 0);
         } else {
             // Strip trailing newline.
             if (size >= 2 && error_message[size - 2] == '\r' && error_message[size - 1] == '\n') {
                 size -= 2;
                 error_message[size] = '\0';
             }
-            PyOS_snprintf(buffer, sizeof(buffer), "LoadLibraryExW '%S' failed: %s", filename, error_message);
+            int ret = PyOS_snprintf(buffer, sizeof(buffer), "LoadLibraryExW '%S' failed: %s", filename, error_message);
+            assert(ret >= 0);
         }
 
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ImportError, buffer);
@@ -723,6 +784,15 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 #else
     // This code would work for all versions, we are avoiding access to interpreter
     // structure internals of 3.8 or higher.
+    // spell-checker: ignore getdlopenflags,dlopenflags
+
+#ifdef __wasi__
+    const char *error = "dynamic libraries are not implemented in wasi";
+    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ImportError, error);
+    return NULL;
+
+    entrypoint_t entrypoint = NULL;
+#else
     static PyObject *dlopenflags_object = NULL;
     if (dlopenflags_object == NULL) {
         dlopenflags_object = CALL_FUNCTION_NO_ARGS(tstate, Nuitka_SysGetObject("getdlopenflags"));
@@ -747,16 +817,11 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     }
 
     entrypoint_t entrypoint = (entrypoint_t)dlsym(handle, entry_function_name);
+#endif // __wasi__
 #endif
     assert(entrypoint);
 
-#if PYTHON_VERSION < 0x370
-    char *old_context = _Py_PackageContext;
-#else
-    char const *old_context = _Py_PackageContext;
-#endif
-
-    _Py_PackageContext = (char *)package;
+    char const *old_context = NuitkaImport_SwapPackageContext(package);
 
     // Finally call into the DLL.
     PGO_onModuleEntered(full_name);
@@ -777,7 +842,13 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
         PySys_WriteStderr("import %s # return from entrypoint\n", full_name);
     }
 
-    _Py_PackageContext = old_context;
+#if 0
+    PRINT_STRING("FRESH");
+    PRINT_ITEM(module);
+    PRINT_NEW_LINE();
+#endif
+
+    NuitkaImport_SwapPackageContext(old_context);
 
 #if PYTHON_VERSION < 0x300
     PyObject *module = Nuitka_GetModuleString(tstate, full_name);
@@ -806,7 +877,10 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 
         PyObject *full_name_obj = Nuitka_String_FromString(full_name);
 
-        PyObject *spec_value = createModuleSpec(tstate, full_name_obj, NULL, false);
+        PyObject *origin = Nuitka_String_FromFilename(filename);
+
+        PyObject *spec_value = createModuleSpec(tstate, full_name_obj, origin, is_package);
+        CHECK_OBJECT(spec_value);
 
         module = PyModule_FromDefAndSpec(def, spec_value);
 
@@ -818,16 +892,25 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
             return NULL;
         }
 
-        setModuleFileValue(tstate, module, filename);
-        PyObject_SetAttrString((PyObject *)spec_value, "origin",
-                               LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__));
         SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
 
+        setModuleFileValue(tstate, module, filename);
+
+        /* Set __path__ properly, unlike frozen module importer does. */
+        PyObject *path_list = _makeDunderPathObject(tstate, origin);
+
+        int res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
+        if (unlikely(res != 0)) {
+            return NULL;
+        }
+
+        Py_DECREF(path_list);
+
         Nuitka_SetModule(full_name_obj, module);
         Py_DECREF(full_name_obj);
 
         SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_True);
-        int res = PyModule_ExecDef(module, def);
+        res = PyModule_ExecDef(module, def);
         SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_False);
 
         Py_DECREF(spec_value);
@@ -847,6 +930,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     } else {
         def = PyModule_GetDef(module);
 
+        def->m_base.m_init = entrypoint;
+
         // Set "__spec__" and "__file__" after load.
         setModuleFileValue(tstate, module, filename);
         PyObject *full_name_obj = Nuitka_String_FromString(full_name);
@@ -905,27 +990,27 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 #else
     PyObject *full_name_obj = PyUnicode_FromString(full_name);
     CHECK_OBJECT(full_name_obj);
-#ifdef _WIN32
-    PyObject *filename_obj = NuitkaUnicode_FromWideChar(filename, -1);
-#else
-    PyObject *filename_obj = PyUnicode_FromString(filename);
-#endif
+    PyObject *filename_obj = Nuitka_String_FromFilename(filename);
+
     CHECK_OBJECT(filename_obj);
 
+#if PYTHON_VERSION < 0x3d0
     int res = _PyImport_FixupExtensionObject(module, full_name_obj, filename_obj
 #if PYTHON_VERSION >= 0x370
                                              ,
                                              Nuitka_GetSysModules()
 #endif
-
     );
+#endif
 
     Py_DECREF(full_name_obj);
     Py_DECREF(filename_obj);
 
+#if PYTHON_VERSION < 0x3d0
     if (unlikely(res == -1)) {
         return NULL;
     }
+#endif
 #endif
 
     return module;
@@ -978,35 +1063,13 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
                             struct Nuitka_MetaPathBasedLoaderEntry const *entry) {
 #ifdef _NUITKA_STANDALONE
     if ((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) != 0) {
-        // Append the the entry name from full path module name with dots,
-        // and translate these into directory separators.
-#ifdef _WIN32
-        wchar_t filename[MAXPATHLEN + 1] = {0};
-
-        appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), sizeof(filename) / sizeof(wchar_t));
-        appendCharSafeW(filename, SEP, sizeof(filename) / sizeof(wchar_t));
-        appendModulenameAsPathW(filename, entry->name, sizeof(filename) / sizeof(wchar_t));
-        appendStringSafeW(filename, ".pyd", sizeof(filename) / sizeof(wchar_t));
-#else
-        char filename[MAXPATHLEN + 1] = {0};
+        bool is_package = (entry->flags & NUITKA_PACKAGE_FLAG) != 0;
 
-        appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), sizeof(filename));
-        appendCharSafe(filename, SEP, sizeof(filename));
-        appendModulenameAsPath(filename, entry->name, sizeof(filename));
-        appendStringSafe(filename, ".so", sizeof(filename));
+        filename_char_t filename[MAXPATHLEN + 1] = {0};
+        _makeModuleCFilenameValue(filename, sizeof(filename) / sizeof(filename_char_t), entry->name, module_name,
+                                  is_package);
 
-#endif
-
-        // Set "__spec__" and "__file__", some modules expect it early.
-        setModuleFileValue(tstate, module, filename);
-#if PYTHON_VERSION >= 0x350
-        PyObject *spec_value =
-            createModuleSpec(tstate, module_name, LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__), false);
-
-        SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
-#endif
-
-        callIntoExtensionModule(tstate, entry->name, filename);
+        callIntoExtensionModule(tstate, entry->name, filename, is_package);
     } else
 #endif
         if ((entry->flags & NUITKA_BYTECODE_FLAG) != 0) {
@@ -1022,20 +1085,26 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
             abort();
         }
 
-        return loadModuleFromCodeObject(module, code_object, entry->name, (entry->flags & NUITKA_PACKAGE_FLAG) != 0);
+        return loadModuleFromCodeObject(tstate, module, code_object, entry->name,
+                                        (entry->flags & NUITKA_PACKAGE_FLAG) != 0);
     } else {
         assert((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) == 0);
-        assert(entry->python_initfunc);
+        assert(entry->python_init_func);
 
-        bool res = Nuitka_SetModule(module_name, module);
-        assert(res != false);
+        {
+            NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModule(module_name, module);
+            assert(res != false);
+        }
 
         // Run the compiled module code, we get the module returned.
-        PyObject *result = entry->python_initfunc(tstate, module, entry);
+#if PYTHON_VERSION < 0x300
+        NUITKA_MAY_BE_UNUSED
+#endif
+        PyObject *result = entry->python_init_func(tstate, module, entry);
         CHECK_OBJECT_X(result);
 
-#if PYTHON_VERSION >= 0x340
-        if (result != NULL) {
+#if PYTHON_VERSION >= 0x300
+        if (likely(result != NULL)) {
             _fixupSpecAttribute(tstate, result);
         }
 #endif
@@ -1071,8 +1140,16 @@ static PyObject *_EXECUTE_EMBEDDED_MODULE(PyThreadState *tstate, PyObject *modul
     PyObject *result = NULL;
 
     if (entry != NULL) {
+#ifdef _NUITKA_EXPERIMENTAL_FORCE_GC_COLLECT_ON_IMPORT
+        PyGC_Collect();
+#endif
+
         result = loadModule(tstate, module, module_name, entry);
 
+#ifdef _NUITKA_EXPERIMENTAL_FORCE_GC_COLLECT_ON_IMPORT
+        PyGC_Collect();
+#endif
+
         if (unlikely(result == NULL)) {
             return NULL;
         }
@@ -1102,7 +1179,7 @@ static PyObject *_EXECUTE_EMBEDDED_MODULE(PyThreadState *tstate, PyObject *modul
         return result;
     }
 
-    Py_INCREF(Py_None);
+    Py_INCREF_IMMORTAL(Py_None);
     return Py_None;
 }
 
@@ -1210,7 +1287,7 @@ static PyObject *_nuitka_loader_is_package(PyObject *self, PyObject *args, PyObj
         result = Py_None;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -1225,7 +1302,9 @@ static PyObject *_nuitka_loader_iter_modules(struct Nuitka_LoaderObject *self, P
         return NULL;
     }
 
-    PyObject *result = MAKE_LIST_EMPTY(0);
+    NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 0);
 
     struct Nuitka_MetaPathBasedLoaderEntry *current = loader_entries;
     assert(current);
@@ -1240,7 +1319,7 @@ static PyObject *_nuitka_loader_iter_modules(struct Nuitka_LoaderObject *self, P
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -1281,9 +1360,9 @@ static PyObject *_nuitka_loader_iter_modules(struct Nuitka_LoaderObject *self, P
             Py_DECREF(old);
         }
 
-        PyObject *r = MAKE_TUPLE_EMPTY(2);
+        PyObject *r = MAKE_TUPLE_EMPTY(tstate, 2);
         PyTuple_SET_ITEM(r, 0, name);
-        PyTuple_SET_ITEM0(r, 1, BOOL_FROM((current->flags & NUITKA_PACKAGE_FLAG) != 0));
+        PyTuple_SET_ITEM_IMMORTAL(r, 1, BOOL_FROM((current->flags & NUITKA_PACKAGE_FLAG) != 0));
 
         LIST_APPEND1(result, r);
 
@@ -1354,35 +1433,6 @@ PyObject *getImportLibBootstrapModule(void) {
 }
 #endif
 
-#if PYTHON_VERSION >= 0x340
-
-static PyObject *_nuitka_loader_repr_module(PyObject *self, PyObject *args, PyObject *kwds) {
-    PyObject *module;
-    PyObject *unused;
-
-    int res =
-        PyArg_ParseTupleAndKeywords(args, kwds, "O|O:module_repr", (char **)_kw_list_find_module, &module, &unused);
-
-    if (unlikely(res == 0)) {
-        return NULL;
-    }
-
-    PyThreadState *tstate = PyThreadState_GET();
-
-    return PyUnicode_FromFormat("<module '%s' from %R>", PyModule_GetName(module),
-                                Nuitka_GetFilenameObject(tstate, module));
-}
-
-static PyObject *getModuleSpecClass(PyObject *importlib_module) {
-    static PyObject *module_spec_class = NULL;
-
-    if (module_spec_class == NULL) {
-        module_spec_class = PyObject_GetAttrString(importlib_module, "ModuleSpec");
-    }
-
-    return module_spec_class;
-}
-
 static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPathBasedLoaderEntry const *entry) {
     PyObject *dir_name = getModuleDirectory(tstate, entry);
 
@@ -1419,6 +1469,35 @@ static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPat
     return result;
 }
 
+#if PYTHON_VERSION >= 0x340
+
+static PyObject *_nuitka_loader_repr_module(PyObject *self, PyObject *args, PyObject *kwds) {
+    PyObject *module;
+    PyObject *unused;
+
+    int res =
+        PyArg_ParseTupleAndKeywords(args, kwds, "O|O:module_repr", (char **)_kw_list_find_module, &module, &unused);
+
+    if (unlikely(res == 0)) {
+        return NULL;
+    }
+
+    PyThreadState *tstate = PyThreadState_GET();
+
+    return PyUnicode_FromFormat("<module '%s' from %R>", PyModule_GetName(module),
+                                Nuitka_GetFilenameObject(tstate, module));
+}
+
+static PyObject *getModuleSpecClass(PyObject *importlib_module) {
+    static PyObject *module_spec_class = NULL;
+
+    if (module_spec_class == NULL) {
+        module_spec_class = PyObject_GetAttrString(importlib_module, "ModuleSpec");
+    }
+
+    return module_spec_class;
+}
+
 static PyObject *createModuleSpec(PyThreadState *tstate, PyObject *module_name, PyObject *origin, bool is_package) {
     CHECK_OBJECT(module_name);
     assert(Nuitka_String_Check(module_name));
@@ -1436,7 +1515,7 @@ static PyObject *createModuleSpec(PyThreadState *tstate, PyObject *module_name,
         return NULL;
     }
 
-    PyObject *args = MAKE_TUPLE2(module_name, (PyObject *)&Nuitka_Loader_Type);
+    PyObject *args = MAKE_TUPLE2(tstate, module_name, (PyObject *)&Nuitka_Loader_Type);
 
     PyObject *kw_values[] = {is_package ? Py_True : Py_False, origin};
 
@@ -1522,7 +1601,7 @@ static PyObject *_nuitka_loader_find_spec(PyObject *self, PyObject *args, PyObje
             PySys_WriteStderr("import %s # denied responsibility\n", full_name);
         }
 
-        Py_INCREF(Py_None);
+        Py_INCREF_IMMORTAL(Py_None);
         return Py_None;
     }
 
@@ -1592,9 +1671,9 @@ static PyObject *_nuitka_loader_exec_module(PyObject *self, PyObject *args, PyOb
 
         if (extension_module_filename != NULL) {
             // Set filename attribute
-            res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, extension_module_filename);
+            bool b_res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, extension_module_filename);
 
-            if (unlikely(res < 0)) {
+            if (unlikely(b_res == false)) {
                 // Might be refuted, which wouldn't be harmful.
                 CLEAR_ERROR_OCCURRED(tstate);
             }
@@ -1662,13 +1741,13 @@ static PyObject *_nuitka_loader_find_distributions(PyObject *self, PyObject *arg
         return NULL;
     }
 
-    PyObject *temp = MAKE_LIST_EMPTY(0);
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *temp = MAKE_LIST_EMPTY(tstate, 0);
 
     Py_ssize_t pos = 0;
     PyObject *distribution_name;
 
-    PyThreadState *tstate = PyThreadState_GET();
-
     while (Nuitka_DistributionNext(&pos, &distribution_name)) {
         bool include = false;
         if (name == Py_None) {
@@ -1687,6 +1766,12 @@ static PyObject *_nuitka_loader_find_distributions(PyObject *self, PyObject *arg
         if (include) {
             // Create a distribution object from our data.
             PyObject *distribution = Nuitka_Distribution_New(tstate, distribution_name);
+
+            if (distribution == NULL) {
+                Py_DECREF(temp);
+                return NULL;
+            }
+
             LIST_APPEND1(temp, distribution);
         }
     }
@@ -1698,7 +1783,7 @@ static PyObject *_nuitka_loader_find_distributions(PyObject *self, PyObject *arg
     return result;
 }
 
-static char const *_kw_list_sys_path_hook[] = {"context", NULL};
+static char const *_kw_list_sys_path_hook[] = {"path", NULL};
 
 static PyObject *_nuitka_loader_sys_path_hook(PyObject *self, PyObject *args, PyObject *kwds) {
     PyObject *path;
@@ -1722,7 +1807,7 @@ static PyObject *_nuitka_loader_sys_path_hook(PyObject *self, PyObject *args, Py
 
     while (entry->name != NULL) {
         if ((entry->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            entry->name = UNTRANSLATE(entry->name);
+            entry->name = UN_TRANSLATE(entry->name);
             entry->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -1779,7 +1864,7 @@ static PyMethodDef Nuitka_Loader_methods[] = {
 
     {"sys_path_hook", (PyCFunction)_nuitka_loader_sys_path_hook, METH_STATIC | METH_VARARGS | METH_KEYWORDS, NULL},
 
-    {NULL, NULL}
+    {NULL, NULL} // terminator
 };
 
 static PyObject *Nuitka_Loader_tp_repr(struct Nuitka_LoaderObject *loader) {
@@ -1809,15 +1894,29 @@ static void Nuitka_Loader_tp_dealloc(struct Nuitka_LoaderObject *loader) {
 
 static int Nuitka_Loader_tp_traverse(struct Nuitka_LoaderObject *loader, visitproc visit, void *arg) { return 0; }
 
+static PyObject *Nuitka_Loader_get_name(struct Nuitka_LoaderObject *loader, void *closure) {
+    PyObject *result = Nuitka_String_FromString(loader->m_loader_entry->name);
+
+    return result;
+}
+static PyObject *Nuitka_Loader_get_path(struct Nuitka_LoaderObject *loader, void *closure) {
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *result = getModuleFileValue(tstate, loader->m_loader_entry);
+
+    return result;
+}
+
 static PyObject *Nuitka_Loader_get__module__(struct Nuitka_LoaderObject *loader, void *closure) {
     PyObject *result = const_str_plain___nuitka__;
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
-static PyGetSetDef Nuitka_Loader_getsets[] = {{(char *)"__module__", (getter)Nuitka_Loader_get__module__, NULL, NULL},
-                                              {NULL}};
+static PyGetSetDef Nuitka_Loader_tp_getset[] = {{(char *)"__module__", (getter)Nuitka_Loader_get__module__, NULL, NULL},
+                                                {(char *)"name", (getter)Nuitka_Loader_get_name, NULL, NULL},
+                                                {(char *)"path", (getter)Nuitka_Loader_get_path, NULL, NULL},
+                                                {NULL}};
 
 PyTypeObject Nuitka_Loader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "nuitka_module_loader",
@@ -1848,7 +1947,7 @@ PyTypeObject Nuitka_Loader_Type = {
     0,                                       // tp_iternext
     Nuitka_Loader_methods,                   // tp_methods
     0,                                       // tp_members
-    Nuitka_Loader_getsets,                   // tp_getset
+    Nuitka_Loader_tp_getset,                 // tp_getset
 };
 
 /* Used by modules to register child loaders for packages. */
@@ -1863,8 +1962,44 @@ PyObject *Nuitka_Loader_New(struct Nuitka_MetaPathBasedLoaderEntry const *entry)
     return (PyObject *)result;
 }
 
-void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *_loader_entries,
-                                    unsigned char **bytecode_data) {
+#ifdef _NUITKA_MODULE
+void updateMetaPathBasedLoaderModuleRoot(char const *module_root_name) {
+    assert(module_root_name != NULL);
+    char const *last_dot = strrchr(module_root_name, '.');
+
+    if (last_dot != NULL) {
+        struct Nuitka_MetaPathBasedLoaderEntry *current = loader_entries;
+        assert(current);
+
+        while (current->name != NULL) {
+            if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
+                current->name = UN_TRANSLATE(current->name);
+                current->flags -= NUITKA_TRANSLATED_FLAG;
+            }
+
+            char name[2048];
+
+            if (strcmp(last_dot + 1, current->name) == 0) {
+                copyStringSafeN(name, module_root_name, last_dot - module_root_name + 1, sizeof(name));
+                appendStringSafe(name, current->name, sizeof(name));
+
+                current->name = strdup(name);
+            } else if (strncmp(last_dot + 1, current->name, strlen(last_dot + 1)) == 0 &&
+                       current->name[strlen(last_dot + 1)] == '.') {
+                copyStringSafeN(name, module_root_name, last_dot - module_root_name + 1, sizeof(name));
+                appendStringSafe(name, current->name, sizeof(name));
+
+                current->name = strdup(name);
+            }
+
+            current++;
+        }
+    }
+}
+#endif
+
+void registerMetaPathBasedLoader(struct Nuitka_MetaPathBasedLoaderEntry *_loader_entries,
+                                 unsigned char **bytecode_data) {
     // Do it only once.
     if (loader_entries) {
         assert(_loader_entries == loader_entries);
@@ -1878,48 +2013,22 @@ void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *_loa
         PySys_WriteStderr("Setup nuitka compiled module/bytecode/extension importer.\n");
     }
 
-#ifdef _NUITKA_MODULE
-    if (_Py_PackageContext != NULL) {
-        char const *last_dot = strrchr(_Py_PackageContext, '.');
-
-        if (last_dot != NULL) {
-            struct Nuitka_MetaPathBasedLoaderEntry *current = _loader_entries;
-            assert(current);
-
-            while (current->name != NULL) {
-                if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-                    current->name = UNTRANSLATE(current->name);
-                    current->flags -= NUITKA_TRANSLATED_FLAG;
-                }
-
-                char name[2048];
-
-                if (strcmp(last_dot + 1, current->name) == 0) {
-                    copyStringSafeN(name, _Py_PackageContext, last_dot - _Py_PackageContext + 1, sizeof(name));
-                    appendStringSafe(name, current->name, sizeof(name));
-
-                    current->name = strdup(name);
-                } else if (strncmp(last_dot + 1, current->name, strlen(last_dot + 1)) == 0 &&
-                           current->name[strlen(last_dot + 1)] == '.') {
-                    copyStringSafeN(name, _Py_PackageContext, last_dot - _Py_PackageContext + 1, sizeof(name));
-                    appendStringSafe(name, current->name, sizeof(name));
-
-                    current->name = strdup(name);
-                }
+    loader_entries = _loader_entries;
 
-                current++;
-            }
-        }
+#if defined(_NUITKA_MODULE) && PYTHON_VERSION < 0x3c0
+    if (_Py_PackageContext != NULL) {
+        updateMetaPathBasedLoaderModuleRoot(_Py_PackageContext);
     }
 #endif
 
-    loader_entries = _loader_entries;
-
     Nuitka_PyType_Ready(&Nuitka_Loader_Type, NULL, true, false, false, false, false);
 
 #ifdef _NUITKA_EXE
-    int res = PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_loader_type", (PyObject *)&Nuitka_Loader_Type);
-    assert(res == 0);
+    {
+        NUITKA_MAY_BE_UNUSED int res =
+            PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_loader_type", (PyObject *)&Nuitka_Loader_Type);
+        assert(res == 0);
+    }
 #endif
 
 #if PYTHON_VERSION >= 0x370
@@ -1961,6 +2070,7 @@ void setEarlyFrozenModulesFileAttribute(PyThreadState *tstate) {
                 PyObject *file_value = MAKE_RELATIVE_PATH_FROM_NAME(Nuitka_String_AsString(key), is_package, false);
                 PyObject_SetAttr(value, const_str_plain___file__, file_value);
                 Py_DECREF(file_value);
+                CHECK_OBJECT(file_value);
             }
         }
     }
@@ -1972,3 +2082,18 @@ void setEarlyFrozenModulesFileAttribute(PyThreadState *tstate) {
 
 // The importlib distribution class is implemented in a separate file.
 #include "MetaPathBasedLoaderImportlibMetadataDistribution.c"
+
+//     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.