Chain every deferred IMPORT_FROM onto the previous placeholder

`lazy from a import b` now records its lookup the same way as `import
a.b as c`, so a placeholder holds either the module name and fromlist or
the previous placeholder and an attribute name, and reification has a
single path.  The import passes only the name being resolved as the
fromlist, so accessing b still does not import the other names'
submodules.

Author: brittanyrey

Lib/test/test_lazy_import/__init__.py

@@ -1177,6 +1177,22 @@ def test_accessing_one_name_leaves_others_as_proxies(self):
         self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}")
         self.assertIn("OK", result.stdout)
 
+    def test_accessing_one_name_imports_only_its_submodule(self):
+        """Accessing one name should not import the other names' submodules."""
+        code = textwrap.dedent("""
+            import sys
+
+            lazy from test.test_lazy_import.data.pkg import b, bar, broken
+
+            # Importing bar prints, and importing broken raises.
+            b.foo()
+
+            assert "test.test_lazy_import.data.pkg.bar" not in sys.modules
+            assert "test.test_lazy_import.data.pkg.broken" not in sys.modules
+        """)
+        rc, out, err = assert_python_ok("-c", code)
+        self.assertEqual(out, b"")
+
     def test_all_names_reified_after_all_accessed(self):
         """All names should be reified after each is accessed."""
         code = textwrap.dedent("""

Lib/test/test_lazy_import/data/pkg/broken.py

@@ -0,0 +1,2 @@
+# Submodule that raises an error during import
+raise ValueError("This module always fails to import")

Objects/lazyimportobject.c

@@ -104,8 +104,6 @@ lazy_import_getattro(PyObject *op, PyObject *name)
     return value;
 }
 
-static PyObject *lazy_import_name(PyLazyImportObject *m);
-
 // The dotted name of the object that resolving the placeholder returns.
 static PyObject *
 lazy_import_path(PyLazyImportObject *m)
@@ -120,7 +118,7 @@ lazy_import_path(PyLazyImportObject *m)
         return res;
     }
     if (m->lz_attr != NULL) {
-        return lazy_import_name(m);
+        return Py_NewRef(m->lz_from);
     }
     // __import__("a.b") returns the top-level package `a`.
     Py_ssize_t dot = PyUnicode_FindChar(
@@ -142,12 +140,7 @@ lazy_import_name(PyLazyImportObject *m)
         return lazy_import_path(m);
     }
     if (m->lz_attr != NULL) {
-        if (PyUnicode_Check(m->lz_attr)) {
-            return PyUnicode_FromFormat("%U.%U", m->lz_from, m->lz_attr);
-        }
-        else {
-            return PyUnicode_FromFormat("%U...", m->lz_from);
-        }
+        return PyUnicode_FromFormat("%U...", m->lz_from);
     }
     return Py_NewRef(m->lz_from);
 }

Python/ceval.c

@@ -3333,14 +3333,12 @@ _PyEval_LazyImportFrom(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObje
     assert(PyUnicode_Check(name));
     PyObject *ret;
     PyLazyImportObject *d = (PyLazyImportObject *)v;
-
-    if (d->lz_attr == NULL || PyUnicode_Check(d->lz_attr)) {
-        // `import a.b.c as d`: record the lookup, to replay once the
-        // import has run.
-        return _PyLazyImport_New(frame, d->lz_builtins, v, name);
+    PyObject *mod = NULL;
+    // Only `from a import b` can take b off an already imported a;
+    // `import a.b as c` has to import a.b first.
+    if (d->lz_attr != NULL && PyTuple_Check(d->lz_attr)) {
+        mod = PyImport_GetModule(d->lz_from);
     }
-
-    PyObject *mod = PyImport_GetModule(d->lz_from);
     if (mod != NULL) {
         // Check if the module already has the attribute, if so, resolve it
         // eagerly.
@@ -3360,7 +3358,7 @@ _PyEval_LazyImportFrom(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObje
         Py_DECREF(mod);
     }
 
-    return _PyLazyImport_New(frame, d->lz_builtins, d->lz_from, name);
+    return _PyLazyImport_New(frame, d->lz_builtins, v, name);
 }
 
 #define CANNOT_CATCH_MSG "catching classes that do not inherit from "\

Python/import.c

@@ -3904,20 +3904,14 @@ static PyObject *
 lazy_import_replay_from(PyThreadState *tstate, PyObject *mod,
                         PyLazyImportObject *lz)
 {
-    PyObject *from;
-    if (PyLazyImport_CheckExact(lz->lz_from)) {
-        from = lazy_import_replay_from(
-            tstate, mod, (PyLazyImportObject *)lz->lz_from);
-        if (from == NULL) {
-            return NULL;
-        }
-    }
-    else if (lz->lz_attr != NULL && PyUnicode_Check(lz->lz_attr)) {
-        from = Py_NewRef(mod);
-    }
-    else {
+    if (!PyLazyImport_CheckExact(lz->lz_from)) {
         return Py_NewRef(mod);
     }
+    PyObject *from = lazy_import_replay_from(
+        tstate, mod, (PyLazyImportObject *)lz->lz_from);
+    if (from == NULL) {
+        return NULL;
+    }
     PyObject *obj = _PyEval_ImportFrom(tstate, from, lz->lz_attr);
     Py_DECREF(from);
     return obj;
@@ -3935,9 +3929,10 @@ _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
     PyLazyImportObject *lz = (PyLazyImportObject *)lazy_import;
     PyInterpreterState *interp = tstate->interp;
 
-    // Walk back to the placeholder IMPORT_NAME left.
-    PyLazyImportObject *root = lz;
+    // Walk back to the placeholder IMPORT_NAME left, and the first lookup on it.
+    PyLazyImportObject *root = lz, *first = NULL;
     while (PyLazyImport_CheckExact(root->lz_from)) {
+        first = root;
         root = (PyLazyImportObject *)root->lz_from;
     }
 
@@ -3988,17 +3983,11 @@ _PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import)
     }
 
     if (root->lz_attr != NULL) {
-        if (PyUnicode_Check(root->lz_attr)) {
-            fromlist = PyTuple_New(1);
-            if (fromlist == NULL) {
-                goto error;
-            }
-            Py_INCREF(root->lz_attr);
-            PyTuple_SET_ITEM(fromlist, 0, root->lz_attr);
-        }
-        else {
-            Py_INCREF(root->lz_attr);
-            fromlist = root->lz_attr;
+        // `from a import b, c`: import only the name being resolved.
+        fromlist = first ? PyTuple_Pack(1, first->lz_attr)
+                         : Py_NewRef(root->lz_attr);
+        if (fromlist == NULL) {
+            goto error;
         }
     }