Namespace implementation

Author: m-novikov

mypy/build.py

@@ -857,6 +857,8 @@ def verify_module(id: str, path: str) -> bool:
     """Check that all packages containing id have a __init__ file."""
     if path.endswith(('__init__.py', '__init__.pyi')):
         path = dirname(path)
+        return True
+
     for i in range(id.count('.')):
         path = dirname(path)
         if not any(os.path.isfile(os.path.join(path, '__init__{}'.format(extension)))
@@ -1457,13 +1459,15 @@ def __init__(self,
         self.order = State.order_counter
         self.caller_state = caller_state
         self.caller_line = caller_line
+        self.namespace = False
         if caller_state:
             self.import_context = caller_state.import_context[:]
             self.import_context.append((caller_state.xpath, caller_line))
         else:
             self.import_context = []
         self.id = id or '__main__'
         self.options = manager.options.clone_for_module(self.id)
+
         if not path and source is None:
             assert id is not None
             file_id = id
@@ -1516,6 +1520,13 @@ def __init__(self,
                     manager.missing_modules.add(id)
                     raise ModuleNotFound
                 else:
+                    if ancestor_for:
+                        self.child_modules = set()
+                        self.ancestors = []
+                        self.dependencies = []
+                        self.suppressed = []
+                        self.namespace = True
+                        return
                     # If we can't find a root source it's always fatal.
                     # TODO: This might hide non-fatal errors from
                     # root sources processed earlier.
@@ -1725,6 +1736,9 @@ def parse_file(self) -> None:
             # The file was already parsed (in __init__()).
             return
 
+        if self.namespace:
+            return
+
         manager = self.manager
         modules = manager.modules
         manager.log("Parsing %s (%s)" % (self.xpath, self.id))
@@ -1743,9 +1757,13 @@ def parse_file(self) -> None:
                 except (UnicodeDecodeError, DecodeError) as decodeerr:
                     raise CompileError([
                         "mypy: can't decode file '{}': {}".format(self.path, str(decodeerr))])
-            assert source is not None
-            self.tree = manager.parse_file(self.id, self.xpath, source,
-                                           self.ignore_all or self.options.ignore_errors)
+
+            if not self.namespace:
+                assert source is not None
+                self.tree = manager.parse_file(self.id, self.xpath, source,
+                                               self.ignore_all or self.options.ignore_errors)
+            else:
+                self.tree = MypyFile([], [])
 
         modules[self.id] = self.tree
 
@@ -1807,13 +1825,20 @@ def parse_file(self) -> None:
         self.check_blockers()
 
     def semantic_analysis(self) -> None:
+        if self.namespace:
+            return
+
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         patches = []  # type: List[Callable[[], None]]
         with self.wrap_context():
             self.manager.semantic_analyzer.visit_file(self.tree, self.xpath, self.options, patches)
         self.patches = patches
 
     def semantic_analysis_pass_three(self) -> None:
+        if self.namespace:
+            self.patches = []
+            return
+
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         patches = []  # type: List[Callable[[], None]]
         with self.wrap_context():
@@ -1828,6 +1853,9 @@ def semantic_analysis_apply_patches(self) -> None:
             patch_func()
 
     def type_check_first_pass(self) -> None:
+        if self.namespace:
+            return
+
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         manager = self.manager
         if self.options.semantic_analysis_only:
@@ -1838,12 +1866,18 @@ def type_check_first_pass(self) -> None:
             self.type_checker.check_first_pass()
 
     def type_check_second_pass(self) -> bool:
+        if self.namespace:
+            return False
+
         if self.options.semantic_analysis_only:
             return False
         with self.wrap_context():
             return self.type_checker.check_second_pass()
 
     def finish_passes(self) -> None:
+        if self.namespace:
+            return
+
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         manager = self.manager
         if self.options.semantic_analysis_only:
@@ -1892,6 +1926,9 @@ def valid_references(self) -> Set[str]:
         return valid_refs
 
     def write_cache(self) -> None:
+        if self.namespace:
+            return
+
         assert self.tree is not None, "Internal error: method must be called on parsed file only"
         if not self.path or self.options.cache_dir == os.devnull:
             return