Remove the patch parent phase

This commit removes the "patch_parent" phase. The logic within those
phases are now run only when a file is actually importing something,
instead of being done automatically.

This fixes some irregularities with how imports are handled. In
particular, the "patch parent" stage was interacting poorly with
implicit module references since the automatic patch would add back in
an explicit module reference even when it was removed, which could
preserve an implicit reference that should have instead been broken.

That is, the presense of "patch parent" was sometimes concealing errors
that should have been caught.

Author: MichaelLeeDBX

mypy/build.py

@@ -1399,19 +1399,6 @@ def parse_file(self) -> None:
         self.dep_line_map = dep_line_map
         self.check_blockers()
 
-    def patch_parent(self) -> None:
-        # Include module in the symbol table of the enclosing package.
-        if '.' not in self.id:
-            return
-        manager = self.manager
-        modules = manager.modules
-        parent, child = self.id.rsplit('.', 1)
-        if parent in modules:
-            manager.trace("Added %s.%s" % (parent, child))
-            modules[parent].names[child] = SymbolTableNode(MODULE_REF, self.tree, parent)
-        else:
-            manager.log("Hm... couldn't add %s.%s" % (parent, child))
-
     def semantic_analysis(self) -> None:
         with self.wrap_context():
             self.manager.semantic_analyzer.visit_file(self.tree, self.xpath)
@@ -1682,8 +1669,6 @@ def process_fresh_scc(graph: Graph, scc: List[str]) -> None:
     """Process the modules in one SCC from their cached data."""
     for id in scc:
         graph[id].load_tree()
-    for id in scc:
-        graph[id].patch_parent()
     for id in scc:
         graph[id].fix_cross_refs()
     for id in scc:
@@ -1697,8 +1682,6 @@ def process_stale_scc(graph: Graph, scc: List[str]) -> None:
         # If the former, parse_file() is a no-op.
         graph[id].parse_file()
         graph[id].fix_suppressed_dependencies(graph)
-    for id in scc:
-        graph[id].patch_parent()
     for id in scc:
         graph[id].semantic_analysis()
     for id in scc:

mypy/semanal.py

@@ -894,6 +894,24 @@ def visit_import(self, i: Import) -> None:
                 base = id.split('.')[0]
                 self.add_module_symbol(base, base, module_public=module_public,
                                        context=i)
+                self.add_parent_modules(id, module_public)
+
+    def add_parent_modules(self, id: str, module_public: bool) -> None:
+        """Adds all parent modules to the symbol table given a fully qualified import.
+
+        It turns out that when you have imports of the form `import a.b.c`, Python will
+        actually import not only module `a.b.c`, but modules `a.b` and `a` as well. This
+        method adds in those checks.
+
+        Note that this does NOT happen when you have imports of the form
+        `import a.b.c as foo` -- here, only module `a.b.c` is loaded under the name `foo`."""
+        while '.' in id:
+            parent, child = id.rsplit('.', 1)
+            if parent in self.modules and id in self.modules:
+                sym = SymbolTableNode(MODULE_REF, self.modules[id], parent,
+                        module_public=module_public)
+                self.modules[parent].names[child] = sym
+            id = parent
 
     def add_module_symbol(self, id: str, as_id: str, module_public: bool,
                           context: Context) -> None:
@@ -910,6 +928,15 @@ def visit_import_from(self, imp: ImportFrom) -> None:
             module = self.modules[import_id]
             for id, as_id in imp.names:
                 node = module.names.get(id)
+
+                # If the module does not contain a symbol with the name 'id',
+                # try checking if it's a module instead.
+                if id not in module.names or node.kind == UNBOUND_IMPORTED:
+                    possible_module_id = import_id + '.' + id
+                    mod = self.modules.get(possible_module_id)
+                    if mod is not None:
+                        node = SymbolTableNode(MODULE_REF, mod, import_id)
+
                 if node and node.kind != UNBOUND_IMPORTED:
                     node = self.normalize_type_alias(node, imp)
                     if not node: