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

nuitka/nodes/ImportNodes.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
+
+
 """ Nodes related to importing modules or names.
 
 Normally imports are mostly relatively static, but Nuitka also attempts to
@@ -26,43 +12,56 @@ deeper that what it normally could. The import expression node can lead to
 modules being added. After optimization it will be asked about used modules.
 """
 
-import os
 import sys
 
 from nuitka.__past__ import long, unicode, xrange
 from nuitka.code_generation.Reports import onMissingTrust
+from nuitka.HardImportRegistry import (
+    addModuleSingleAttributeNodeFactory,
+    hard_modules_aliases,
+    hard_modules_limited,
+    hard_modules_non_stdlib,
+    hard_modules_stdlib,
+    hard_modules_trust,
+    isHardModule,
+    isHardModuleWithoutSideEffect,
+    trust_constant,
+    trust_importable,
+    trust_may_exist,
+    trust_node,
+    trust_node_factory,
+    trust_undefined,
+)
 from nuitka.importing.Importing import (
+    isNonRaisingBuiltinModule,
     isPackageDir,
     locateModule,
     makeModuleUsageAttempt,
+    makeParentModuleUsagesAttempts,
 )
 from nuitka.importing.ImportResolving import resolveModuleName
 from nuitka.importing.Recursion import decideRecursion
 from nuitka.importing.StandardLibrary import isStandardLibraryPath
 from nuitka.Options import (
+    isExperimental,
     isStandaloneMode,
     shallMakeModule,
     shallWarnUnusualCode,
 )
-from nuitka.PythonVersions import (
-    getFutureModuleKeys,
-    getImportlibSubPackages,
-    python_version,
-)
+from nuitka.plugins.Plugins import Plugins
+from nuitka.PythonVersions import python_version
 from nuitka.specs.BuiltinParameterSpecs import (
     BuiltinParameterSpec,
     extractBuiltinArgs,
 )
 from nuitka.Tracing import unusual_logger
 from nuitka.utils.ModuleNames import ModuleName
-from nuitka.utils.Utils import isWin32Windows
 
 from .ChildrenHavingMixins import (
     ChildHavingModuleMixin,
     ChildrenExpressionBuiltinImportMixin,
     ChildrenExpressionImportlibImportModuleCallMixin,
 )
-from .ConstantRefNodes import ExpressionConstantSysVersionInfoRef
 from .ExpressionBases import ExpressionBase
 from .ImportHardNodes import (
     ExpressionImportHardBase,
@@ -79,270 +78,6 @@ from .NodeMakingHelpers import (
 from .shapes.BuiltinTypeShapes import tshape_module, tshape_module_builtin
 from .StatementBasesGenerated import StatementImportStarBase
 
-# These module are supported in code generation to be imported the hard way.
-hard_modules = frozenset(
-    (
-        "os",
-        "ntpath",
-        "posixpath",
-        # TODO: Add mac path package too
-        "sys",
-        "types",
-        "typing",
-        "__future__",
-        "importlib",
-        "importlib.resources",
-        "importlib.metadata",
-        "_frozen_importlib",
-        "_frozen_importlib_external",
-        "pkgutil",
-        "functools",
-        "sysconfig",
-        "unittest",
-        "unittest.mock",
-        # "cStringIO",
-        "io",
-        "_io",
-        "ctypes",
-        "ctypes.wintypes",
-        "ctypes.macholib",
-        # TODO: Once generation of nodes for functions exists.
-        # "platform",
-    )
-)
-
-hard_modules_aliases = {
-    "os.path": os.path.__name__,
-}
-
-# Lets put here, hard modules that are kind of backports only.
-hard_modules_stdlib = hard_modules
-hard_modules_non_stdlib = frozenset(
-    (
-        "site",
-        "pkg_resources",
-        "importlib_metadata",
-        "importlib_resources",
-    )
-)
-
-hard_modules = hard_modules | hard_modules_non_stdlib
-
-hard_modules_version = {
-    "cStringIO": (None, 0x300, None),
-    "typing": (0x350, None, None),
-    "_frozen_importlib": (0x300, None, None),
-    "_frozen_importlib_external": (0x350, None, None),
-    "importlib.resources": (0x370, None, None),
-    "importlib.metadata": (0x380, None, None),
-    "ctypes.wintypes": (None, None, "win32"),
-}
-
-hard_modules_limited = ("importlib.metadata", "ctypes.wintypes", "importlib_metadata")
-
-
-def isHardModule(module_name):
-    if module_name not in hard_modules:
-        return False
-
-    min_version, max_version, os_limit = hard_modules_version.get(
-        module_name, (None, None, None)
-    )
-
-    if min_version is not None and python_version < min_version:
-        return False
-
-    if max_version is not None and python_version >= max_version:
-        return False
-
-    if os_limit is not None:
-        if os_limit == "win32":
-            return isWin32Windows()
-
-    return True
-
-
-trust_undefined = 0
-trust_constant = 1
-trust_exist = 2
-trust_future = trust_exist
-trust_importable = 3
-trust_node = 4
-trust_may_exist = 5
-trust_not_exist = 6
-trust_node_factory = {}
-
-module_importlib_trust = dict(
-    (key, trust_importable) for key in getImportlibSubPackages()
-)
-
-if "metadata" not in module_importlib_trust:
-    module_importlib_trust["metadata"] = trust_undefined
-if "resources" not in module_importlib_trust:
-    module_importlib_trust["resources"] = trust_undefined
-
-module_sys_trust = {
-    "version": trust_constant,
-    "hexversion": trust_constant,
-    "platform": trust_constant,
-    "maxsize": trust_constant,
-    "byteorder": trust_constant,
-    "builtin_module_names": trust_constant,
-    "stdout": trust_exist,
-    "stderr": trust_exist,
-}
-
-if python_version < 0x270:
-    module_sys_trust["version_info"] = trust_constant
-else:
-    module_sys_trust["version_info"] = trust_node
-    trust_node_factory[("sys", "version_info")] = ExpressionConstantSysVersionInfoRef
-
-if python_version < 0x300:
-    module_sys_trust["exc_type"] = trust_may_exist
-    module_sys_trust["exc_value"] = trust_may_exist
-    module_sys_trust["exc_traceback"] = trust_may_exist
-
-    module_sys_trust["maxint"] = trust_constant
-    module_sys_trust["subversion"] = trust_constant
-else:
-    module_sys_trust["exc_type"] = trust_not_exist
-    module_sys_trust["exc_value"] = trust_not_exist
-    module_sys_trust["exc_traceback"] = trust_not_exist
-
-module_typing_trust = {
-    "TYPE_CHECKING": trust_constant,
-}
-
-module_os_trust = {
-    "name": trust_constant,
-    "listdir": trust_node,
-    "curdir": trust_constant,
-    "pardir": trust_constant,
-    "sep": trust_constant,
-    "extsep": trust_constant,
-    "altsep": trust_constant,
-    "pathsep": trust_constant,
-    "linesep": trust_constant,
-}
-
-module_os_path_trust = {
-    "exists": trust_node,
-    "isfile": trust_node,
-    "isdir": trust_node,
-    "basename": trust_node,
-}
-
-
-module_ctypes_trust = {
-    "CDLL": trust_node,
-}
-
-# module_platform_trust = {"python_implementation": trust_function}
-
-hard_modules_trust = {
-    "os": module_os_trust,
-    "ntpath": module_os_path_trust if os.path.__name__ == "ntpath" else {},
-    "posixpath": module_os_path_trust if os.path.__name__ == "posixpath" else {},
-    "sys": module_sys_trust,
-    #     "platform": module_platform_trust,
-    "types": {},
-    "typing": module_typing_trust,
-    "__future__": dict((key, trust_future) for key in getFutureModuleKeys()),
-    "importlib": module_importlib_trust,
-    "importlib.metadata": {
-        "version": trust_node,
-        "distribution": trust_node,
-        "metadata": trust_node,
-        "entry_points": trust_node,
-        "PackageNotFoundError": trust_exist,
-    },
-    "importlib_metadata": {
-        "version": trust_node,
-        "distribution": trust_node,
-        "metadata": trust_node,
-        "entry_points": trust_node,
-        "PackageNotFoundError": trust_exist,
-    },
-    "_frozen_importlib": {},
-    "_frozen_importlib_external": {},
-    "pkgutil": {"get_data": trust_node},
-    "functools": {"partial": trust_exist},
-    "sysconfig": {},
-    # TODO: We should have trust_module too.
-    "unittest": {"mock": trust_exist},
-    "unittest.mock": {},
-    "io": {"BytesIO": trust_exist, "StringIO": trust_exist},
-    "_io": {"BytesIO": trust_exist, "StringIO": trust_exist},
-    # "cStringIO": {"StringIO": trust_exist},
-    "pkg_resources": {
-        "require": trust_node,
-        "get_distribution": trust_node,
-        "iter_entry_points": trust_node,
-        "resource_string": trust_node,
-        "resource_stream": trust_node,
-    },
-    "importlib.resources": {
-        "read_binary": trust_node,
-        "read_text": trust_node,
-        "files": trust_node,
-    },
-    "importlib_resources": {
-        "read_binary": trust_node,
-        "read_text": trust_node,
-        "files": trust_node,
-    },
-    "ctypes": module_ctypes_trust,
-    "site": {},
-    "ctypes.wintypes": {},
-    "ctypes.macholib": {},
-}
-
-
-def _addHardImportNodeClasses():
-    from .HardImportNodesGenerated import hard_import_node_classes
-
-    for hard_import_node_class, spec in hard_import_node_classes.items():
-        module_name, function_name = spec.name.rsplit(".", 1)
-
-        if module_name in hard_modules_aliases:
-            module_name = hard_modules_aliases.get(module_name)
-
-        trust_node_factory[(module_name, function_name)] = hard_import_node_class
-
-        # hard_modules_trust[module_name][function_name] = trust_node
-
-
-_addHardImportNodeClasses()
-
-# Remove this one again, not available on Windows, but the node generation does
-# not know that.
-if isWin32Windows():
-    module_os_trust["uname"] = trust_not_exist
-
-
-def _checkHardModules():
-    for module_name in hard_modules:
-        assert module_name in hard_modules_trust, module_name
-
-    for module_name, trust in hard_modules_trust.items():
-        assert module_name in hard_modules, module_name
-
-        for attribute_name, trust_value in trust.items():
-            if trust_value is trust_node:
-                assert (
-                    module_name,
-                    attribute_name,
-                ) in trust_node_factory or os.path.basename(sys.argv[0]).startswith(
-                    "generate-"
-                ), (
-                    module_name,
-                    attribute_name,
-                )
-
-
-_checkHardModules()
-
 
 def makeExpressionImportModuleNameHard(
     module_name, import_name, module_guaranteed, source_ref
@@ -363,25 +98,13 @@ def makeExpressionImportModuleNameHard(
         )
 
 
-# These modules can cause issues if imported during compile time.
-hard_modules_trust_with_side_effects = set(["site"])
-if not isWin32Windows():
-    # Crashing on anything but Windows.
-    hard_modules_trust_with_side_effects.add("ctypes.wintypes")
-
-
-def isHardModuleWithoutSideEffect(module_name):
-    return (
-        module_name in hard_modules
-        and module_name not in hard_modules_trust_with_side_effects
-    )
-
-
 class ExpressionImportAllowanceMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
-    def __init__(self):
+    def __init__(self, using_module_name):
+        self.using_module_name = using_module_name
+
         if self.finding == "not-found":
             self.allowed = False
         elif self.finding == "built-in":
@@ -390,7 +113,7 @@ class ExpressionImportAllowanceMixin(object):
             self.allowed = True
         else:
             self.allowed, _reason = decideRecursion(
-                using_module_name=None,
+                using_module_name=self.using_module_name,
                 module_filename=self.module_filename,
                 module_name=self.module_name,
                 module_kind=self.module_kind,
@@ -413,17 +136,19 @@ class ExpressionImportModuleFixed(ExpressionBase):
 
     __slots__ = (
         "module_name",
+        "value_name",
         "found_module_name",
         "found_module_filename",
         "module_kind",
         "finding",
-        "allowance",
+        "module_usages",
     )
 
-    def __init__(self, module_name, source_ref):
+    def __init__(self, module_name, value_name, source_ref):
         ExpressionBase.__init__(self, source_ref)
 
         self.module_name = ModuleName(module_name)
+        self.value_name = ModuleName(value_name)
 
         self.finding = None
 
@@ -435,6 +160,18 @@ class ExpressionImportModuleFixed(ExpressionBase):
             self.finding,
         ) = self._attemptFollow()
 
+        self.module_usages = makeParentModuleUsagesAttempts(
+            makeModuleUsageAttempt(
+                module_name=self.found_module_name,
+                filename=self.found_module_filename,
+                finding=self.finding,
+                module_kind=self.module_kind,
+                level=0,
+                source_ref=self.source_ref,
+                reason="import",
+            )
+        )
+
     # TODO: This is called in constructor only, is it, then inline it.
     def _attemptFollow(self):
         found_module_name, found_module_filename, module_kind, finding = locateModule(
@@ -470,11 +207,14 @@ class ExpressionImportModuleFixed(ExpressionBase):
         del self.parent
 
     def getDetails(self):
-        return {"module_name": self.module_name}
+        return {"module_name": self.module_name, "value_name": self.value_name}
 
     def getModuleName(self):
         return self.module_name
 
+    def getValueName(self):
+        return self.value_name
+
     @staticmethod
     def mayHaveSideEffects():
         # TODO: For included modules, we might be able to tell, not not done now.
@@ -486,28 +226,119 @@ class ExpressionImportModuleFixed(ExpressionBase):
         return True
 
     def getTypeShape(self):
+        # TODO: This ought to be dead code, built-in modules have their own nodes now
+        # and may only be hard imports, but not this.
         if self.module_name in sys.builtin_module_names:
             return tshape_module_builtin
         else:
             return tshape_module
 
-    def getModuleUsageAttempt(self):
-        return makeModuleUsageAttempt(
-            module_name=self.found_module_name,
-            filename=self.found_module_filename,
-            finding=self.finding,
-            module_kind=self.module_kind,
+    def getModuleUsageAttempts(self):
+        return self.module_usages
+
+    def computeExpressionRaw(self, trace_collection):
+        if self.mayRaiseException(BaseException):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+        # Trace the module usage attempt.
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
+
+        # Nothing to do about it.
+        return self, None, None
+
+    def computeExpressionImportName(self, import_node, import_name, trace_collection):
+        # TODO: For include modules, something might be possible here, consider self.allowance
+        # when that is implemented.
+        return self.computeExpressionAttribute(
+            lookup_node=import_node,
+            attribute_name=import_name,
+            trace_collection=trace_collection,
+        )
+
+
+class ExpressionImportModuleBuiltin(ExpressionBase):
+    """Hard coded import names, that we know to exist."
+
+    These created as result of builtin imports and "importlib.import_module" calls
+    that were compile time resolved, and for known module names.
+    """
+
+    kind = "EXPRESSION_IMPORT_MODULE_BUILTIN"
+
+    __slots__ = (
+        "module_name",
+        "value_name",
+        "module_kind",
+        "builtin_module",
+        "module_usages",
+    )
+
+    def __init__(self, module_name, value_name, source_ref):
+        ExpressionBase.__init__(self, source_ref)
+
+        self.module_name = ModuleName(module_name)
+        self.value_name = ModuleName(value_name)
+
+        self.builtin_module = __import__(module_name.asString())
+
+        # If not found, we import the package at least
+        _module_name, _module_filename, _module_kind, _finding = locateModule(
+            module_name=self.module_name,
+            parent_package=None,
             level=0,
-            source_ref=self.source_ref,
-            reason="import",
         )
 
+        assert _module_name == self.module_name, _module_name
+        assert _finding == "built-in", _finding
+        assert _module_kind is None, _module_kind
+
+        self.module_usages = makeParentModuleUsagesAttempts(
+            makeModuleUsageAttempt(
+                module_name=self.module_name,
+                filename=None,
+                finding="built-in",
+                module_kind=None,
+                level=0,
+                source_ref=self.source_ref,
+                reason="import",
+            )
+        )
+
+    @staticmethod
+    def getTypeShape():
+        return tshape_module_builtin
+
+    def mayRaiseExceptionImportName(self, exception_type, import_name):
+        return not hasattr(self.builtin_module, import_name)
+
+    def finalize(self):
+        del self.parent
+
+    def getDetails(self):
+        return {"module_name": self.module_name, "value_name": self.value_name}
+
+    def getModuleName(self):
+        return self.module_name
+
+    def getValueName(self):
+        return self.value_name
+
+    @staticmethod
+    def mayHaveSideEffects():
+        return True
+
+    def mayRaiseException(self, exception_type):
+        return isNonRaisingBuiltinModule(self.module_name) is not False
+
+    def getModuleUsageAttempts(self):
+        return self.module_usages
+
     def computeExpressionRaw(self, trace_collection):
         if self.mayRaiseException(BaseException):
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         # Nothing to do about it.
         return self, None, None
@@ -533,17 +364,26 @@ class ExpressionImportModuleHard(
 
     kind = "EXPRESSION_IMPORT_MODULE_HARD"
 
-    __slots__ = ("module", "allowed", "guaranteed", "value_name", "is_package")
+    __slots__ = (
+        "using_module_name",
+        "module",
+        "allowed",
+        "guaranteed",
+        "value_name",
+        "is_package",
+    )
 
-    def __init__(self, module_name, value_name, source_ref):
+    def __init__(self, using_module_name, module_name, value_name, source_ref):
         ExpressionImportHardBase.__init__(
             self, module_name=module_name, source_ref=source_ref
         )
 
-        ExpressionImportAllowanceMixin.__init__(self)
-
         self.value_name = value_name
 
+        ExpressionImportAllowanceMixin.__init__(
+            self, using_module_name=using_module_name
+        )
+
         if self.finding != "not-found" and isHardModuleWithoutSideEffect(
             self.module_name
         ):
@@ -571,7 +411,11 @@ class ExpressionImportModuleHard(
         del self.parent
 
     def getDetails(self):
-        return {"module_name": self.module_name, "value_name": self.value_name}
+        return {
+            "using_module_name": self.using_module_name,
+            "module_name": self.module_name,
+            "value_name": self.value_name,
+        }
 
     def getModuleName(self):
         return self.module_name
@@ -596,7 +440,7 @@ class ExpressionImportModuleHard(
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+        trace_collection.onModuleUsageAttempts(self.getModuleUsageAttempts())
 
         return self, None, None
 
@@ -647,15 +491,18 @@ class ExpressionImportModuleHard(
     def _computeExpressionAttribute(
         self, lookup_node, attribute_name, trace_collection, is_import
     ):
-        # Return driven handling of many cases, pylint: disable=too-many-return-statements
+        # Return driven handling of many cases
+        # pylint: disable=too-many-branches,too-many-return-statements
 
-        if self.module is not None and self.allowed:
+        if self.allowed:
             full_name = self.value_name.getChildNamed(attribute_name)
-
             full_name = ModuleName(hard_modules_aliases.get(full_name, full_name))
 
             if isHardModule(full_name):
+                trace_collection.onExceptionRaiseExit(BaseException)
+
                 new_node = ExpressionImportModuleHard(
+                    using_module_name=self.using_module_name,
                     module_name=full_name,
                     value_name=full_name,
                     source_ref=lookup_node.source_ref,
@@ -668,9 +515,12 @@ class ExpressionImportModuleHard(
                     % (self.value_name, attribute_name),
                 )
 
-            trust = hard_modules_trust[self.value_name].get(
-                attribute_name, trust_undefined
-            )
+            if self.value_name in hard_modules_trust:
+                trust = hard_modules_trust[self.value_name].get(
+                    attribute_name, trust_undefined
+                )
+            else:
+                trust = trust_undefined
 
             if trust is trust_importable:
                 # TODO: Change this is a hard module import itself, currently these are not all trusted
@@ -679,8 +529,10 @@ class ExpressionImportModuleHard(
                 trace_collection.onExceptionRaiseExit(BaseException)
             elif trust is trust_may_exist:
                 trace_collection.onExceptionRaiseExit(BaseException)
-            elif trust is not trust_undefined and not hasattr(
-                self.module, attribute_name
+            elif (
+                trust is not trust_undefined
+                and self.module is not None
+                and not hasattr(self.module, attribute_name)
             ):
                 # TODO: Unify with below branches.
                 trace_collection.onExceptionRaiseExit(ImportError)
@@ -699,28 +551,36 @@ class ExpressionImportModuleHard(
                 )
             else:
                 if trust is trust_undefined:
-                    # TODO: Should add this, such that these imports are
-                    # properly resolved: pylint: disable=condition-evals-to-constant
-
-                    if self.is_package and False:
+                    # Need to attempt module imports if this is for an import
+                    # lookup of code like "from value_name import attribute_name".
+                    if self.is_package:
                         full_name = self.value_name.getChildNamed(attribute_name)
 
-                        _sub_module_name, _sub_module_filename, finding = locateModule(
+                        (
+                            _sub_module_name,
+                            _sub_module_filename,
+                            _sub_module_kind,
+                            finding,
+                        ) = locateModule(
                             module_name=full_name,
                             parent_package=None,
                             level=0,
                         )
 
                         if finding != "not-found":
+                            trace_collection.onExceptionRaiseExit(ImportError)
+
                             result = makeExpressionImportModuleFixed(
+                                using_module_name=self.getParentModule().getFullName(),
                                 module_name=full_name,
+                                value_name=full_name,
                                 source_ref=lookup_node.getSourceReference(),
                             )
 
                             return (
                                 result,
                                 "new_expression",
-                                "Attribute lookup '%s* of hard module *%s* becomes hard module name import."
+                                "Attribute lookup '%s' of hard module '%s' becomes hard module name import."
                                 % (self.value_name, attribute_name),
                             )
 
@@ -732,7 +592,7 @@ class ExpressionImportModuleHard(
                         self.value_name,
                         attribute_name,
                     )
-                elif trust is trust_constant:
+                elif trust is trust_constant and self.module is not None:
                     # Make sure it's actually there, and not becoming the getattr default by accident.
                     assert hasattr(self.module, attribute_name), self
 
@@ -747,6 +607,9 @@ class ExpressionImportModuleHard(
                         % (self.value_name, attribute_name),
                     )
                 elif trust is trust_node:
+                    # TODO: Unify with other branches.
+                    trace_collection.onExceptionRaiseExit(ImportError)
+
                     result = trust_node_factory[self.value_name, attribute_name](
                         source_ref=lookup_node.source_ref
                     )
@@ -919,7 +782,10 @@ class ExpressionImportlibImportModuleCall(
                     trace_collection.onExceptionRaiseExit(BaseException)
 
                     result = makeExpressionImportModuleFixed(
-                        module_name=resolved_module_name, source_ref=self.source_ref
+                        using_module_name=self.getParentModule().getFullName(),
+                        module_name=resolved_module_name,
+                        value_name=resolved_module_name,
+                        source_ref=self.source_ref,
                     )
 
                     return (
@@ -943,8 +809,33 @@ class ExpressionImportlibImportModuleCall(
         return self, None, None
 
 
-module_importlib_trust["import_module"] = trust_node
-trust_node_factory[("importlib", "import_module")] = ExpressionImportlibImportModuleRef
+addModuleSingleAttributeNodeFactory(
+    "importlib", "import_module", ExpressionImportlibImportModuleRef
+)
+
+
+def _makeParentImportModuleUsages(module_name, source_ref):
+    for parent_package_name in module_name.getParentPackageNames():
+        (
+            _parent_package_name,
+            parent_module_filename,
+            parent_module_kind,
+            parent_module_finding,
+        ) = locateModule(
+            module_name=parent_package_name,
+            parent_package=None,
+            level=0,
+        )
+
+        yield makeModuleUsageAttempt(
+            module_name=parent_package_name,
+            filename=parent_module_filename,
+            finding=parent_module_finding,
+            module_kind=parent_module_kind,
+            level=0,
+            source_ref=source_ref,
+            reason="import path parent",
+        )
 
 
 class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBase):
@@ -952,8 +843,6 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
         "follow_attempted",
         "finding",
         "used_modules",
-        "type_shape",
-        "builtin_module",
     )
 
     kind = "EXPRESSION_BUILTIN_IMPORT"
@@ -984,33 +873,41 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
         # imports are considered too.
         self.used_modules = []
 
-        self.type_shape = tshape_module
-
-        self.builtin_module = None
-
         self.finding = None
 
-    def _attemptFollow(self, module_name):
-        # Complex stuff, pylint: disable=too-many-branches,too-many-locals
-
+    def _getLevelValue(self):
         parent_module = self.getParentModule()
-
-        parent_package = parent_module.getFullName()
-        if not parent_module.isCompiledPythonPackage():
-            parent_package = parent_package.getPackageName()
-
         level = self.subnode_level
 
         if level is None:
-            level = 0 if parent_module.getFutureSpec().isAbsoluteImport() else -1
+            return 0 if parent_module.getFutureSpec().isAbsoluteImport() else -1
         elif not level.isCompileTimeConstant():
-            return
+            return None
         else:
-            level = level.getCompileTimeConstant()
+            level_value = level.getCompileTimeConstant()
 
-        # TODO: Catch this as a static error maybe.
-        if type(level) not in (int, long):
-            return None
+            # TODO: Catch this as a static error maybe.
+            if type(level_value) not in (int, long):
+                return None
+
+            return level_value
+
+    def _attemptFollow(self, module_name):
+        # Complex stuff, pylint: disable=too-many-branches
+
+        # Without the level value, we don't know what it is.
+        level_value = self._getLevelValue()
+        if level_value is None:
+            return
+
+        parent_module = self.getParentModule()
+
+        if level_value != 0:
+            parent_package = parent_module.getFullName()
+            if not parent_module.isCompiledPythonPackage():
+                parent_package = parent_package.getPackageName()
+        else:
+            parent_package = None
 
         module_name_resolved = resolveModuleName(module_name)
         if module_name_resolved != module_name:
@@ -1024,25 +921,36 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 )
             )
 
-        module_name, module_filename, module_kind, self.finding = locateModule(
-            module_name=resolveModuleName(module_name),
+        module_name = ModuleName(module_name)
+        module_name_found, module_filename, module_kind, self.finding = locateModule(
+            module_name=ModuleName(module_name),
             parent_package=parent_package,
-            level=level,
+            level=level_value,
         )
 
-        self.used_modules = [
+        # Allow for the import look ahead, to change what modules are
+        # considered hard imports.
+        Plugins.onModuleUsageLookAhead(
+            module_name=module_name_found,
+            module_filename=module_filename,
+            module_kind=module_kind,
+        )
+
+        self.used_modules = makeParentModuleUsagesAttempts(
             makeModuleUsageAttempt(
-                module_name=module_name,
+                module_name=module_name_found,
                 filename=module_filename,
                 module_kind=module_kind,
                 finding=self.finding,
-                level=level,
+                level=level_value,
                 source_ref=self.source_ref,
                 reason="import",
             )
-        ]
+        )
 
         if self.finding != "not-found":
+            module_name = module_name_found
+
             import_list = self.subnode_fromlist
 
             if import_list is not None:
@@ -1072,6 +980,8 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                         level=1,  # Relative import
                     )
 
+                    self.used_modules = list(self.used_modules)
+
                     self.used_modules.append(
                         makeModuleUsageAttempt(
                             module_name=name_import_module_name,
@@ -1080,51 +990,29 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                             finding=name_import_finding,
                             level=1,
                             source_ref=self.source_ref,
-                            reason="import",
+                            reason="import fromlist",
                         )
                     )
 
+                self.used_modules = tuple(self.used_modules)
+
             return module_filename
         else:
-            module_name = resolveModuleName(module_name)
-
-            while True:
-                module_name = module_name.getPackageName()
-
-                if not module_name:
-                    break
-
-                (
-                    found_module_name,
-                    module_filename,
-                    module_kind,
-                    finding,
-                ) = locateModule(
-                    module_name=module_name,
-                    parent_package=parent_package,
-                    level=level,
-                )
-
-                self.used_modules.append(
-                    makeModuleUsageAttempt(
-                        module_name=found_module_name,
-                        filename=module_filename,
-                        module_kind=module_kind,
-                        finding=finding,
-                        level=level,
-                        source_ref=self.source_ref,
-                        reason="import",
-                    )
-                )
+            return None
 
-                if finding != "not-found":
-                    break
+    def _getImportedValueName(self, imported_module_name):
+        from_list_truth = (
+            self.subnode_fromlist is not None and self.subnode_fromlist.getTruthValue()
+        )
 
-            return None
+        if from_list_truth is True:
+            return imported_module_name
+        else:
+            return imported_module_name.getTopLevelPackageName()
 
     def computeExpression(self, trace_collection):
-        # Attempt to recurse if not already done, many cases to consider
-        # pylint: disable=too-many-branches
+        # Attempt to recurse if not already done, many cases to consider and its
+        # return driven, pylint: disable=too-many-branches,too-many-return-statements
         if self.follow_attempted:
             if self.finding == "not-found":
                 # Importing and not finding, may raise an exception obviously.
@@ -1134,8 +1022,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 trace_collection.onExceptionRaiseExit(RuntimeError)
 
             # Trace the module usage attempts.
-            for module_usage_attempt in self.used_modules:
-                trace_collection.onModuleUsageAttempt(module_usage_attempt)
+            trace_collection.onModuleUsageAttempts(self.used_modules)
 
             # We stay here.
             return self, None, None
@@ -1158,34 +1045,82 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 trace_collection.onModuleUsageAttempt(module_usage_attempt)
 
             if type(imported_module_name) in (str, unicode):
-                imported_module_name = resolveModuleName(imported_module_name)
+                if self.finding == "relative":
+                    parent_module = self.getParentModule()
+
+                    parent_package = parent_module.getFullName()
+                    if not parent_module.isCompiledPythonPackage():
+                        parent_package = parent_package.getPackageName()
+
+                    level_value = abs(self._getLevelValue())
+                    level_value -= 1
+
+                    while level_value > 0:
+                        parent_package = parent_package.getPackageName()
+                        level_value -= 1
+
+                    if imported_module_name != "":
+                        candidate_module_name = parent_package.getChildNamed(
+                            imported_module_name
+                        )
+                    else:
+                        candidate_module_name = parent_package
 
-                if self.finding == "absolute" and isHardModule(imported_module_name):
                     if (
-                        imported_module_name in hard_modules_non_stdlib
+                        candidate_module_name in hard_modules_non_stdlib
+                        or module_filename is None
                         or isStandardLibraryPath(module_filename)
                     ):
-                        from_list_truth = (
-                            self.subnode_fromlist is not None
-                            and self.subnode_fromlist.getTruthValue()
+                        result = ExpressionImportModuleHard(
+                            using_module_name=self.getParentModule().getFullName(),
+                            module_name=candidate_module_name,
+                            value_name=self._getImportedValueName(
+                                candidate_module_name
+                            ),
+                            source_ref=self.source_ref,
+                        )
+
+                        return (
+                            result,
+                            "new_expression",
+                            "Lowered import %s module '%s' to hard import."
+                            % (
+                                (
+                                    "hard import"
+                                    if candidate_module_name in hard_modules_non_stdlib
+                                    else "standard library"
+                                ),
+                                candidate_module_name.asString(),
+                            ),
                         )
 
-                        if from_list_truth is True:
-                            value_name = imported_module_name
-                        else:
-                            value_name = imported_module_name.getTopLevelPackageName()
+                imported_module_name = resolveModuleName(imported_module_name)
 
+                if self.finding == "absolute" and isHardModule(imported_module_name):
+                    if (
+                        imported_module_name in hard_modules_non_stdlib
+                        or module_filename is None
+                        or isStandardLibraryPath(module_filename)
+                    ):
                         result = ExpressionImportModuleHard(
+                            using_module_name=self.getParentModule().getFullName(),
                             module_name=imported_module_name,
-                            value_name=value_name,
+                            value_name=self._getImportedValueName(imported_module_name),
                             source_ref=self.source_ref,
                         )
 
                         return (
                             result,
                             "new_expression",
-                            "Lowered import of standard library module '%s' to hard import."
-                            % imported_module_name.asString(),
+                            "Lowered import %s module '%s' to hard import."
+                            % (
+                                (
+                                    "hard import"
+                                    if imported_module_name in hard_modules_non_stdlib
+                                    else "standard library"
+                                ),
+                                imported_module_name.asString(),
+                            ),
                         )
                     elif shallWarnUnusualCode():
                         unusual_logger.warning(
@@ -1197,23 +1132,24 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                             )
                         )
 
-                if self.finding == "built-in":
-                    if isHardModule(imported_module_name):
-                        result = ExpressionImportModuleHard(
-                            module_name=imported_module_name,
-                            value_name=imported_module_name.getTopLevelPackageName(),
-                            source_ref=self.source_ref,
-                        )
+                # Built-in module imports can be specialized right away.
 
-                        return (
-                            result,
-                            "new_expression",
-                            "Lowered import of built-in module '%s' to hard import."
-                            % imported_module_name.asString(),
-                        )
+                if self.finding == "built-in":
+                    result = makeExpressionImportModuleBuiltin(
+                        using_module_name=self.getParentModule().getFullName(),
+                        module_name=imported_module_name,
+                        value_name=self._getImportedValueName(imported_module_name),
+                        source_ref=self.source_ref,
+                    )
 
-                    self.type_shape = tshape_module_builtin
-                    self.builtin_module = __import__(imported_module_name.asString())
+                    # TODO: This ought to preserve side effects from arguments
+                    # for full compatibility with strange uses of __import__
+                    return (
+                        result,
+                        "new_expression",
+                        "Lowered import of built-in module '%s' to hard import."
+                        % imported_module_name.asString(),
+                    )
 
                 if self.finding == "not-found":
                     if imported_module_name in hard_modules_limited:
@@ -1228,6 +1164,26 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                             % imported_module_name.asString(),
                         )
 
+                elif (
+                    isStandaloneMode()
+                    and self.used_modules
+                    and isExperimental("standalone-imports")
+                ):
+                    result = makeExpressionImportModuleFixed(
+                        using_module_name=self.getParentModule().getFullName(),
+                        module_name=self.used_modules[0].module_name,
+                        value_name=self._getImportedValueName(
+                            self.used_modules[0].module_name
+                        ),
+                        source_ref=self.source_ref,
+                    )
+
+                    return (
+                        result,
+                        "new_expression",
+                        "Lowered import of module '%s' to fixed import."
+                        % imported_module_name.asString(),
+                    )
             else:
                 # TODO: This doesn't preserve side effects.
 
@@ -1263,15 +1219,6 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
     def mayRaiseException(self, exception_type):
         return self.finding != "built-in"
 
-    def mayRaiseExceptionImportName(self, exception_type, import_name):
-        if self.finding == "built-in":
-            return not hasattr(self.builtin_module, import_name)
-        else:
-            return True
-
-    def getTypeShape(self):
-        return self.type_shape
-
 
 class StatementImportStar(StatementImportStarBase):
     kind = "STATEMENT_IMPORT_STAR"
@@ -1354,16 +1301,59 @@ class ExpressionImportName(ChildHavingModuleMixin, ExpressionBase):
         )
 
 
-def makeExpressionImportModuleFixed(module_name, source_ref):
+def makeExpressionImportModuleFixed(
+    using_module_name, module_name, value_name, source_ref
+):
     module_name = resolveModuleName(module_name)
+    value_name = resolveModuleName(value_name)
 
     if isHardModule(module_name):
         return ExpressionImportModuleHard(
+            using_module_name=using_module_name,
             module_name=module_name,
-            value_name=module_name.getTopLevelPackageName(),
+            value_name=value_name,
             source_ref=source_ref,
         )
     else:
         return ExpressionImportModuleFixed(
-            module_name=module_name, source_ref=source_ref
+            module_name=module_name,
+            value_name=value_name,
+            source_ref=source_ref,
+        )
+
+
+def makeExpressionImportModuleBuiltin(
+    using_module_name, module_name, value_name, source_ref
+):
+    module_name = resolveModuleName(module_name)
+    value_name = resolveModuleName(value_name)
+
+    if isHardModule(module_name):
+        return ExpressionImportModuleHard(
+            using_module_name=using_module_name,
+            module_name=module_name,
+            value_name=value_name,
+            source_ref=source_ref,
+        )
+    else:
+        return ExpressionImportModuleBuiltin(
+            module_name=module_name,
+            value_name=value_name,
+            source_ref=source_ref,
         )
+
+
+#     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.