Explicitly don't handle import from

Author: ilevkivskyi

mypy/build.py

@@ -744,6 +744,26 @@ def getmtime(self, path: str) -> int:
         else:
             return int(self.metastore.getmtime(path))
 
+    def correct_rel_imp(self, file: MypyFile, imp: ImportFrom | ImportAll) -> str:
+        """Function to correct for relative imports."""
+        file_id = file.fullname
+        rel = imp.relative
+        if rel == 0:
+            return imp.id
+        if os.path.basename(file.path).startswith("__init__."):
+            rel -= 1
+        if rel != 0:
+            file_id = ".".join(file_id.split(".")[:-rel])
+        new_id = file_id + "." + imp.id if imp.id else file_id
+
+        if not new_id:
+            self.errors.set_file(file.path, file.name, self.options)
+            self.errors.report(
+                imp.line, 0, "No parent module -- cannot perform relative import", blocker=True
+            )
+
+        return new_id
+
     def all_imported_modules_in_file(self, file: MypyFile) -> list[tuple[int, str, int]]:
         """Find all reachable import statements in a file.
 
@@ -752,27 +772,6 @@ def all_imported_modules_in_file(self, file: MypyFile) -> list[tuple[int, str, i
 
         Can generate blocking errors on bogus relative imports.
         """
-
-        def correct_rel_imp(imp: ImportFrom | ImportAll) -> str:
-            """Function to correct for relative imports."""
-            file_id = file.fullname
-            rel = imp.relative
-            if rel == 0:
-                return imp.id
-            if os.path.basename(file.path).startswith("__init__."):
-                rel -= 1
-            if rel != 0:
-                file_id = ".".join(file_id.split(".")[:-rel])
-            new_id = file_id + "." + imp.id if imp.id else file_id
-
-            if not new_id:
-                self.errors.set_file(file.path, file.name, self.options)
-                self.errors.report(
-                    imp.line, 0, "No parent module -- cannot perform relative import", blocker=True
-                )
-
-            return new_id
-
         res: list[tuple[int, str, int]] = []
         for imp in file.imports:
             if not imp.is_unreachable:
@@ -787,7 +786,7 @@ def correct_rel_imp(imp: ImportFrom | ImportAll) -> str:
                             ancestors.append(part)
                             res.append((ancestor_pri, ".".join(ancestors), imp.line))
                 elif isinstance(imp, ImportFrom):
-                    cur_id = correct_rel_imp(imp)
+                    cur_id = self.correct_rel_imp(file, imp)
                     all_are_submodules = True
                     # Also add any imported names that are submodules.
                     pri = import_priority(imp, PRI_MED)
@@ -807,7 +806,7 @@ def correct_rel_imp(imp: ImportFrom | ImportAll) -> str:
                     res.append((pri, cur_id, imp.line))
                 elif isinstance(imp, ImportAll):
                     pri = import_priority(imp, PRI_HIGH)
-                    res.append((pri, correct_rel_imp(imp), imp.line))
+                    res.append((pri, self.correct_rel_imp(file, imp), imp.line))
 
         # Sort such that module (e.g. foo.bar.baz) comes before its ancestors (e.g. foo
         # and foo.bar) so that, if FindModuleCache finds the target module in a
@@ -2901,9 +2900,7 @@ def dispatch(sources: list[BuildSource], manager: BuildManager, stdout: TextIO)
         graph = load_graph(sources, manager)
 
     for id in graph:
-        ancestors = graph[id].ancestors
-        assert ancestors is not None
-        manager.import_map[id] = set(graph[id].dependencies + graph[id].suppressed + ancestors)
+        manager.import_map[id] = set(graph[id].dependencies + graph[id].suppressed)
 
     t1 = time.time()
     manager.add_stats(

mypy/semanal.py

@@ -537,6 +537,13 @@ def __init__(
         self.type_expression_full_parse_failure_count: int = 0  # Failed full parses
 
         # Imports of submodules transitively visible from given module.
+        # This is needed to support patterns like this
+        #   [a.py]
+        #     import b
+        #     import foo
+        #     foo.bar  # <- this should work even if bar is not re-exported in foo
+        #   [b.py]
+        #     import foo.bar
         self.transitive_submodule_imports: dict[str, set[str]] = {}
 
     # mypyc doesn't properly handle implementing an abstractproperty
@@ -6642,7 +6649,7 @@ def get_module_symbol(self, node: MypyFile, name: str) -> SymbolTableNode | None
         sym = names.get(name)
         if not sym:
             fullname = module + "." + name
-            if fullname in self.modules and self.is_visible_import(fullname):
+            if fullname in self.modules and self.is_visible_import(module, fullname):
                 sym = SymbolTableNode(GDEF, self.modules[fullname])
             elif self.is_incomplete_namespace(module):
                 self.record_incomplete_ref()
@@ -6661,12 +6668,20 @@ def get_module_symbol(self, node: MypyFile, name: str) -> SymbolTableNode | None
             sym = None
         return sym
 
-    def is_visible_import(self, id: str) -> bool:
+    def is_visible_import(self, base_id: str, id: str) -> bool:
+        if base_id not in self.transitive_submodule_imports:
+            # This is a performance optimization for a common pattern. If one module
+            # in a codebase uses import numpy as np; np.foo.bar, then it is likely that
+            # other modules use similar pattern as well. So we pre-compute transitive
+            # dependencies for np, to avoid possible duplicate work in the future.
+            self.add_transitive_submodule_imports(base_id)
         if self.cur_mod_id not in self.transitive_submodule_imports:
             self.add_transitive_submodule_imports(self.cur_mod_id)
         return id in self.transitive_submodule_imports[self.cur_mod_id]
 
     def add_transitive_submodule_imports(self, mod_id: str) -> None:
+        if mod_id not in self.import_map:
+            return
         todo = self.import_map[mod_id]
         seen = {mod_id}
         result = {mod_id}

test-data/unit/check-incremental.test

@@ -7543,8 +7543,43 @@ tmp/a.py:3: error: "object" has no attribute "submod"
 tmp/a.py:3: error: "object" has no attribute "submod"
 
 [case testIncrementalAccessSubmoduleWithoutExplicitImportNested]
+import a
+
+[file a.py]
+import pandas
+pandas.core.dtypes
+
+[file a.py.2]
+import pandas
+pandas.core.dtypes
+# touch
+
+[file pandas/__init__.py]
+import pandas.core.api
+
+[file pandas/core/__init__.py]
+[file pandas/core/api.py]
+import pandas.core.dtypes.dtypes
+
+[file pandas/core/dtypes/__init__.py]
+[file pandas/core/dtypes/dtypes.py]
+X = 0
+[out]
+[out2]
+
+[case testIncrementalAccessSubmoduleWithoutExplicitImportNestedFrom]
+import a
+
+[file a.py]
 import pandas
 
+# Although this actually works at runtime, we do not support this, since
+# this would cause major slowdown for a rare edge case. This test verifies
+# that we fail consistently on cold and warm runs.
+pandas.core.dtypes
+
+[file a.py.2]
+import pandas
 pandas.core.dtypes
 
 [file pandas/__init__.py]
@@ -7558,4 +7593,6 @@ from pandas.core.dtypes.dtypes import X
 [file pandas/core/dtypes/dtypes.py]
 X = 0
 [out]
+tmp/a.py:6: error: "object" has no attribute "dtypes"
 [out2]
+tmp/a.py:2: error: "object" has no attribute "dtypes"