Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/nodes/ImportNodes.py

@@ -26,12 +26,28 @@ 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,
@@ -40,29 +56,24 @@ 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.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 +90,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 +110,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 +125,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 +148,18 @@ class ExpressionImportModuleFixed(ExpressionBase):
 
     __slots__ = (
         "module_name",
+        "value_name",
         "found_module_name",
         "found_module_filename",
         "module_kind",
         "finding",
-        "allowance",
     )
 
-    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
 
@@ -470,11 +206,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,6 +225,8 @@ 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:
@@ -522,6 +263,98 @@ class ExpressionImportModuleFixed(ExpressionBase):
         )
 
 
+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",
+    )
+
+    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,
+        )
+
+        assert _module_name == self.module_name, _module_name
+        assert _finding == "built-in", _finding
+        assert _module_kind is None, _module_kind
+
+    @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 getModuleUsageAttempt(self):
+        return makeModuleUsageAttempt(
+            module_name=self.module_name,
+            filename=None,
+            finding="built-in",
+            module_kind=None,
+            level=0,
+            source_ref=self.source_ref,
+            reason="import",
+        )
+
+    def computeExpressionRaw(self, trace_collection):
+        if self.mayRaiseException(BaseException):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+        # Trace the module usage attempt.
+        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
+
+        # 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 ExpressionImportModuleHard(
     ExpressionImportAllowanceMixin, ExpressionImportHardBase
 ):
@@ -533,17 +366,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 +413,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
@@ -656,6 +502,7 @@ class ExpressionImportModuleHard(
 
             if isHardModule(full_name):
                 new_node = ExpressionImportModuleHard(
+                    using_module_name=self.using_module_name,
                     module_name=full_name,
                     value_name=full_name,
                     source_ref=lookup_node.source_ref,
@@ -699,13 +546,17 @@ 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,
@@ -713,7 +564,9 @@ class ExpressionImportModuleHard(
 
                         if finding != "not-found":
                             result = makeExpressionImportModuleFixed(
+                                using_module_name=self.getParentModule().getFullName(),
                                 module_name=full_name,
+                                value_name=full_name,
                                 source_ref=lookup_node.getSourceReference(),
                             )
 
@@ -747,6 +600,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 +775,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 +802,9 @@ 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
+)
 
 
 class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBase):
@@ -952,8 +812,6 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
         "follow_attempted",
         "finding",
         "used_modules",
-        "type_shape",
-        "builtin_module",
     )
 
     kind = "EXPRESSION_BUILTIN_IMPORT"
@@ -984,10 +842,6 @@ 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):
@@ -995,10 +849,6 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
 
         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:
@@ -1008,6 +858,13 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
         else:
             level = level.getCompileTimeConstant()
 
+        if level != 0:
+            parent_package = parent_module.getFullName()
+            if not parent_module.isCompiledPythonPackage():
+                parent_package = parent_package.getPackageName()
+        else:
+            parent_package = None
+
         # TODO: Catch this as a static error maybe.
         if type(level) not in (int, long):
             return None
@@ -1024,15 +881,16 @@ 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,
         )
 
         self.used_modules = [
             makeModuleUsageAttempt(
-                module_name=module_name,
+                module_name=module_name_found,
                 filename=module_filename,
                 module_kind=module_kind,
                 finding=self.finding,
@@ -1043,6 +901,8 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
         ]
 
         if self.finding != "not-found":
+            module_name = module_name_found
+
             import_list = self.subnode_fromlist
 
             if import_list is not None:
@@ -1086,8 +946,6 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
 
             return module_filename
         else:
-            module_name = resolveModuleName(module_name)
-
             while True:
                 module_name = module_name.getPackageName()
 
@@ -1122,9 +980,19 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
 
             return None
 
+    def _getImportedValueName(self, imported_module_name):
+        from_list_truth = (
+            self.subnode_fromlist is not None and self.subnode_fromlist.getTruthValue()
+        )
+
+        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.
@@ -1163,29 +1031,28 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                 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)
                     ):
-                        from_list_truth = (
-                            self.subnode_fromlist is not None
-                            and self.subnode_fromlist.getTruthValue()
-                        )
-
-                        if from_list_truth is True:
-                            value_name = imported_module_name
-                        else:
-                            value_name = imported_module_name.getTopLevelPackageName()
-
                         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 +1064,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 +1096,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 +1151,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 +1233,43 @@ 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,
         )