gh-152298: Cover reentrant lazy owner finalization

Author: 1sgtpepper

Doc/library/types.rst

@@ -355,10 +355,10 @@ Standard names are defined for the following types:
       Resolve the lazy import and return the imported object. Successful
       resolutions are cached.
 
-      For module-level lazy imports, ``resolve()`` replaces the original global
-      only while it still refers to this proxy. If that binding was deleted or
-      rebound, it is left unchanged and later ``resolve()`` calls on the same
-      proxy do not update it.
+      For a module-level lazy import, ``resolve()`` also updates the original
+      module global if that name still refers to this proxy. If the name was
+      deleted or rebound, it is left unchanged; later ``resolve()`` calls return
+      the cached object without updating that name.
 
    .. versionadded:: 3.15
 

Include/internal/pycore_lazyimportobject.h

@@ -21,7 +21,7 @@ typedef struct {
     PyObject *lz_attr;
     // Protected by the import lock. lz_owner_* records the first module
     // global that resolve() may replace. Pending owners are being stored;
-    // finalized owners cannot be claimed again.
+    // pending and finalized may overlap during reentrant store resolution.
     PyObject *lz_owner_globals;
     PyObject *lz_owner_key;
     PyObject *lz_resolved;

Lib/test/test_lazy_import/__init__.py

@@ -732,8 +732,8 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                 return real_import(name, globals, locals, fromlist, level)
 
             def check():
-                proxy = globals()["primary"]
-                globals()["secondary"] = proxy
+                exec('secondary = globals()["primary"]', globals())
+                proxy = globals()["secondary"]
 
                 resolved = proxy.resolve()
                 assert globals()["primary"] is resolved
@@ -752,6 +752,54 @@ def check():
         """)
         assert_python_ok("-c", code)
 
+    @support.requires_subprocess()
+    def test_reentrant_store_resolution_clears_pending_owner(self):
+        code = textwrap.dedent("""
+            import builtins
+            import types
+
+            real_import = builtins.__import__
+            calls = []
+            errors = []
+            proxies = []
+
+            def custom_import(name, globals=None, locals=None, fromlist=None,
+                              level=0):
+                if name == "target_module":
+                    calls.append(name)
+                    resolved = types.ModuleType(name)
+                    resolved.VALUE = "resolved"
+                    return resolved
+                return real_import(name, globals, locals, fromlist, level)
+
+            class Reenter:
+                def __del__(self):
+                    try:
+                        proxies.append(globals()["target"])
+                        assert target.VALUE == "resolved"
+                    except BaseException as exc:
+                        errors.append((type(exc).__name__, str(exc)))
+
+            builtins.__import__ = custom_import
+            target = Reenter()
+            lazy import target_module as target
+
+            try:
+                assert not errors, errors
+                assert len(proxies) == 1, proxies
+                resolved = globals()["target"]
+                proxy = proxies[0]
+                assert resolved.VALUE == "resolved"
+
+                globals()["target"] = proxy
+                assert proxy.resolve() is resolved
+                assert globals()["target"] is proxy
+                assert len(calls) == 1, calls
+            finally:
+                builtins.__import__ = real_import
+        """)
+        assert_python_ok("-c", code)
+
 
 class SyntaxRestrictionTests(LazyImportTestCase):
     """Tests for syntax restrictions on lazy imports."""

Objects/lazyimportobject.c

@@ -201,11 +201,8 @@ _PyLazyImport_FinishGlobalBinding(PyThreadState *tstate, PyObject *op,
     PyInterpreterState *interp = tstate->interp;
     _PyImport_AcquireLock(interp);
     if (m->lz_owner_pending && owner_matches(m, globals, name)) {
-        if (stored) {
-            m->lz_owner_pending = 0;
-        }
-        else {
-            m->lz_owner_pending = 0;
+        m->lz_owner_pending = 0;
+        if (!stored) {
             Py_CLEAR(m->lz_owner_globals);
             Py_CLEAR(m->lz_owner_key);
         }
@@ -220,10 +217,7 @@ finalize_owner_if_matches(PyThreadState *tstate, PyLazyImportObject *m,
     int finalized = 0;
     PyInterpreterState *interp = tstate->interp;
     _PyImport_AcquireLock(interp);
-    if (!m->lz_owner_pending &&
-        !m->lz_owner_finalized &&
-        owner_matches(m, globals, name))
-    {
+    if (!m->lz_owner_finalized && owner_matches(m, globals, name)) {
         m->lz_owner_finalized = 1;
         finalized = 1;
     }