Import of submodule shadowing parent module attribute fails under lazy_imports mode

[jacobtylerwalls]

Bug report

Bug description:

For this module structure:

└─ a/
   ├─ __init__.py    # Contains a function foo()
   └─ foo.py

This script passes on 3.14...

from a import foo
import a.foo
import types
assert isinstance(a.foo, types.ModuleType), type(a.foo)

And fails on 3.15 with lazy imports (python3.15 -X lazy_imports=all script.py):

Traceback (most recent call last):
  File "/Users/jwalls/script.py", line 4, in <module>
    assert isinstance(a.foo, types.ModuleType), type(a.foo)
           ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: <class 'function'>

CPython versions tested on:

3.15

Operating systems tested on:

macOS

[harjothkhara]

Confirmed still reproducing on main (ce916dc). Here's the root cause, in case it's useful.

The two pieces that interact:

1. import a.foo under -X lazy_imports=all defers the submodule import and only records "foo" as a pending submodule of "a" — Python/import.c#L4601 → register_lazy_on_parent(), which adds "foo" to lazy_pending_submodules["a"].

2. The deferred binding is supposed to happen in _Py_module_getattro_impl when a.foo is accessed, but the lookup order shadows it. In Objects/moduleobject.c:

   • the generic dict lookup finds the real foo function that a/__init__.py defined, and a found non-lazy attribute is returned immediately at L1377 (return attr;);
   • try_load_lazy_submodule(m, name) at L1393 is only reached when the attribute is absent, so the pending submodule is never resolved.

So a same-named attribute set by the package __init__ permanently shadows a pending submodule, and the deferred import a.foo never runs its binding.

Why eager mode (3.14) doesn't have this: eager import a.foo goes through importlib._bootstrap._find_and_load, which does setattr(parent, child, child_module) unconditionally after importing the child, overwriting the function. Lazy mode moves that bind into getattro, but getattro resolves precedence the other way around.

The fix looks like it belongs in _Py_module_getattro_impl: when a found attribute is not a lazy placeholder but name is a registered pending submodule, the pending submodule should take precedence (mirroring eager import a.foo, where the explicit import statement rebinds the parent attribute). Before committing to that, though, I wanted to check the intended semantics, since this overlaps the precedence work in gh-144957 and gh-150052:

• Should an explicit import a.foo always win over an __init__-defined a.foo attribute under lazy mode (matching eager)?
• Or is the intent to preserve the __init__ attribute, in which case this is arguably the documented divergence and the eager/lazy mismatch is acceptable?

Happy to put up a PR with a regression test in test_lazy_import once the desired precedence is confirmed.