Keep the import bootstrap identical to pinned CPython

Remove the RustPython-only reorder dispatcher and restore the exact rc3 bootstrap. Retain the atomic dictionary primitive and its direct regression assertions, without claiming it fixes import-cache ordering without a caller. Assisted-by: Codex:model-version-unavailable
youknowdot · Oct 2, 2026 · Oct 2, 2026 · Oct 2, 2026 · Oct 2, 2026 · Oct 2, 2026
commit f593a38886ed76b7c2099050c167f43618bf03cf
diff --git a/Lib/importlib/_bootstrap.py b/Lib/importlib/_bootstrap.py
@@ -872,19 +872,6 @@ def _module_repr_from_spec(spec):
             return f'<module {spec.name!r} ({spec.origin})>'
 
 
-def _reorder_module(spec):
-    # RustPython: an exact dict can update shutdown order without exposing a
-    # temporarily absent module to another importing thread.
-    modules = sys.modules
-    if type(modules) is dict and hasattr(_imp, '_dict_move_to_end'):
-        return _imp._dict_move_to_end(modules, spec.name)
-    # Preserve custom pop/setitem behavior, including a pop that rebinds
-    # sys.modules or changes spec.name. CPython also uses this fallback.
-    module = sys.modules.pop(spec.name)
-    sys.modules[spec.name] = module
-    return module
-
-
 # Used by importlib.reload().
 def _exec(spec, module):
     """Execute the spec's specified module in an existing module's namespace."""
@@ -905,7 +892,8 @@ def _exec(spec, module):
         finally:
             # Update the order of insertion into sys.modules for module
             # clean-up at shutdown.
-            module = _reorder_module(spec)
+            module = sys.modules.pop(spec.name)
+            sys.modules[spec.name] = module
     return module
 
 def _load_unlocked(spec):
@@ -935,7 +923,8 @@ def _load_unlocked(spec):
         # We don't ensure that the import-related module attributes get
         # set in the sys.modules replacement case.  Such modules are on
         # their own.
-        module = _reorder_module(spec)
+        module = sys.modules.pop(spec.name)
+        sys.modules[spec.name] = module
         _verbose_message('import {!r} # {!r}', spec.name, spec.loader)
     finally:
         spec._initializing = False

diff --git a/extra_tests/snippets/import_atomic_reorder.py b/extra_tests/snippets/import_atomic_reorder.py
@@ -1,14 +1,10 @@
-"""Import-cache ordering must not temporarily remove an exact-dict entry.
+"""Exercise the native atomic dictionary-relocation primitive.
 
-The native relocation helper and trace-visible presence assertion protect
-RustPython's module-cache atomicity and callback reentry boundaries.
+The copied CPython import bootstrap does not call this private helper.
 """
 
 import _imp
-import os
 import sys
-import types
-from importlib import _bootstrap as frozen
 
 
 def raises(kind, call, expected=None):
@@ -21,172 +17,6 @@ def raises(kind, call, expected=None):
     raise AssertionError(f"{kind.__name__} was not raised")
 
 
-def source_bootstrap():
-    path = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
-        "Lib",
-        "importlib",
-        "_bootstrap.py",
-    )
-    source = types.ModuleType("atomic_reorder_source_bootstrap")
-    with open(path, encoding="utf-8") as stream:
-        exec(compile(stream.read(), path, "exec"), source.__dict__)
-    for name in (
-        "sys",
-        "_imp",
-        "_thread",
-        "_warnings",
-        "_weakref",
-        "_bootstrap_external",
-    ):
-        setattr(source, name, getattr(frozen, name))
-    source._blocking_on = source._WeakValueDictionary()
-    return source
-
-
-class Loader:
-    def __init__(self, action):
-        self.action = action
-
-    def create_module(self, spec):
-        return None
-
-    def exec_module(self, module):
-        self.action(module)
-
-
-def check_trace_presence(bootstrap, mode):
-    original = sys.modules
-    old_trace = sys.gettrace()
-    name = "_atomic_reorder_trace"
-    expected = types.ModuleType(name)
-    after = "_atomic_reorder_trace_after"
-    state = {"armed": False, "events": 0}
-    failure = RuntimeError("legacy loader failed with its entry still present")
-    codes = {
-        bootstrap._exec.__code__,
-        bootstrap._load_unlocked.__code__,
-    }
-    if hasattr(bootstrap, "_load_backward_compatible"):
-        codes.add(bootstrap._load_backward_compatible.__code__)
-    if hasattr(bootstrap, "_reorder_module"):
-        codes.add(bootstrap._reorder_module.__code__)
-
-    def trace(frame, event, arg):
-        if event == "line" and state["armed"] and frame.f_code in codes:
-            state["events"] += 1
-            assert name in sys.modules, (mode, frame.f_code.co_name, frame.f_lineno)
-            assert sys.modules[name] is expected
-        return trace
-
-    def finish(module):
-        sys.modules[name] = expected
-        sys.modules[after] = object()
-        state["armed"] = True
-
-    class LegacyLoader:
-        def load_module(self, fullname):
-            assert fullname == name
-            finish(expected)
-            if mode == "legacy_error":
-                raise failure
-            return expected
-
-    try:
-        sys.modules = original.copy()
-        loader = LegacyLoader() if mode.startswith("legacy") else Loader(finish)
-        spec = bootstrap.ModuleSpec(name, loader)
-        if mode == "exec":
-            initial = bootstrap.module_from_spec(spec)
-            sys.modules[name] = initial
-            call = lambda: bootstrap._exec(spec, initial)
-        elif mode.startswith("legacy"):
-            call = lambda: bootstrap._load_backward_compatible(spec)
-        else:
-            call = lambda: bootstrap._load_unlocked(spec)
-        sys.settrace(trace)
-        if mode == "legacy_error":
-            raises(RuntimeError, call, failure)
-        else:
-            assert call() is expected
-        sys.settrace(old_trace)
-        assert state["events"] > 0, "the successful loader window was not traced"
-        assert list(sys.modules)[-2:] == [after, name]
-    finally:
-        sys.settrace(old_trace)
-        sys.modules = original
-
-
-def check_custom_mappings(bootstrap):
-    original = sys.modules
-    name = "_atomic_reorder_custom"
-    value = object()
-    events = []
-
-    class Subclass(dict):
-        def pop(self, key):
-            events.append(("pop", key))
-            return super().pop(key)
-
-        def __setitem__(self, key, value):
-            events.append(("set", key, value))
-            super().__setitem__(key, value)
-
-    class Mapping:
-        def __init__(self, pairs):
-            self.data = dict(pairs)
-
-        def pop(self, key):
-            events.append(("pop", key))
-            return self.data.pop(key)
-
-        def __setitem__(self, key, value):
-            events.append(("set", key, value))
-            self.data[key] = value
-
-    try:
-        spec = bootstrap.ModuleSpec(name, None)
-        for cls in (Subclass, Mapping):
-            events.clear()
-            modules = cls([(name, value), ("after", None)])
-            sys.modules = modules
-            assert bootstrap._reorder_module(spec) is value
-            assert events == [("pop", name), ("set", name, value)]
-            assert list(modules if cls is Subclass else modules.data) == ["after", name]
-
-        rebound = Subclass()
-        new_name = "_atomic_reorder_rebound"
-
-        class Rebinding(Subclass):
-            def pop(self, key):
-                result = super().pop(key)
-                sys.modules = rebound
-                spec.name = new_name
-                return result
-
-        events.clear()
-        modules = Rebinding({name: value})
-        sys.modules = modules
-        assert bootstrap._reorder_module(spec) is value
-        assert events == [("pop", name), ("set", new_name, value)]
-        assert sys.modules is rebound
-        assert rebound[new_name] is value
-        assert name not in modules
-
-        failure = KeyError("custom pop exception")
-
-        class Raising(Subclass):
-            def pop(self, key):
-                raise failure
-
-        events.clear()
-        sys.modules = Raising({new_name: value})
-        raises(KeyError, lambda: bootstrap._reorder_module(spec), failure)
-        assert events == []
-    finally:
-        sys.modules = original
-
-
 def check_native_helper():
     move = _imp._dict_move_to_end
     first, middle, last = object(), object(), object()
@@ -343,18 +173,5 @@ def __del__(self):
     assert mapping == {"finalized": True}
 
 
-source = source_bootstrap()
-for bootstrap in (frozen, source):
-    if sys.implementation.name == "rustpython":
-        # Run this before inspecting the new helper so a baseline executable
-        # fails on the actual pop/set gap, not just a missing private API.
-        modes = ("load", "exec")
-        if hasattr(bootstrap, "_load_backward_compatible"):
-            modes += ("legacy", "legacy_error")
-        for mode in modes:
-            check_trace_presence(bootstrap, mode)
-    if hasattr(bootstrap, "_reorder_module"):
-        check_custom_mappings(bootstrap)
-
 if sys.implementation.name == "rustpython":
     check_native_helper()