WIP 2

Author: MichaelLeeDBX

mypy/build.py

@@ -29,6 +29,7 @@
                         SymbolTableNode, MODULE_REF)
 from mypy.semanal import FirstPass, SemanticAnalyzer, ThirdPass
 from mypy.checker import TypeChecker
+from mypy.indirection import IndirectionDetector
 from mypy.errors import Errors, CompileError, DecodeError, report_internal_error
 from mypy import fixup
 from mypy.report import Reports
@@ -352,6 +353,7 @@ def __init__(self, data_dir: str,
         self.modules = self.semantic_analyzer.modules
         self.semantic_analyzer_pass3 = ThirdPass(self.modules, self.errors)
         self.type_checker = TypeChecker(self.errors, self.modules, options=options)
+        self.indirection_detector = IndirectionDetector()
         self.missing_modules = set()  # type: Set[str]
         self.stale_modules = set()  # type: Set[str]
         self.rechecked_modules = set()  # type: Set[str]
@@ -1269,7 +1271,7 @@ def load_tree(self) -> None:
         self.manager.modules[self.id] = self.tree
 
     def fix_cross_refs(self) -> None:
-        fixup_module_pass_one(self.tree, self.manager.modules, self.valid_references())
+        fixup_module_pass_one(self.tree, self.manager.modules)
 
     def calculate_mros(self) -> None:
         fixup_module_pass_two(self.tree, self.manager.modules)
@@ -1418,25 +1420,38 @@ def type_check(self) -> None:
         if manager.options.semantic_analysis_only:
             return
         with self.wrap_context():
-            manager.type_checker.visit_file(self.tree, self.xpath, self.valid_references())
-            encountered = manager.type_checker.get_encountered()
-            #for dep in encountered - self.valid_references():
-            #    self.dependencies.append(dep)
-            #    self.priorities[dep] = PRI_INDIRECT
+            manager.type_checker.type_map = {}
+            manager.type_checker.visit_file(self.tree, self.xpath, set())
+            # encountered = manager.type_checker.get_encountered()
+            # print(manager.type_checker.type_map)
 
             if manager.options.dump_inference_stats:
                 dump_type_stats(self.tree, self.xpath, inferred=True,
                                 typemap=manager.type_checker.type_map)
             manager.report_file(self.tree)
 
+    def detect_indirection(self) -> None:
+        self.manager.indirection_detector.modules = set()
+        # self.manager.indirection_detector.visit_mypy_file(self.tree)
+        for item, val in self.manager.type_checker.type_map.items():
+            self.manager.indirection_detector._visit(item)
+            self.manager.indirection_detector._visit_types(val)
+
+        encountered = self.manager.indirection_detector.modules
+        valid = self.valid_references()
+        extra = encountered - valid
+        for dep in extra:
+            self.dependencies.append(dep)
+            self.priorities[dep] = PRI_INDIRECT
+
     def valid_references(self) -> Set[str]:
         valid_refs = set(self.dependencies + self.suppressed + self.ancestors)
         valid_refs .add(self.id)
 
         if "os" in valid_refs:
             valid_refs.add("os.path")
 
-        return valid_refs 
+        return valid_refs
 
     def write_cache(self) -> None:
         if self.path and self.manager.options.incremental and not self.manager.errors.is_errors():
@@ -1691,6 +1706,7 @@ def process_stale_scc(graph: Graph, scc: List[str]) -> None:
         graph[id].semantic_analysis_pass_three()
     for id in scc:
         graph[id].type_check()
+        graph[id].detect_indirection()
         graph[id].write_cache()
         graph[id].mark_as_rechecked()
 

mypy/checkexpr.py

@@ -75,9 +75,9 @@ def visit_name_expr(self, e: NameExpr) -> Type:
 
         It can be of any kind: local, member or global.
         """
-        if e.kind == MODULE_REF and e.fullname not in self.chk.valid_module_references:
-            self.chk.encountered.add(e.fullname)
-            self.chk.msg.indirect_import(e.fullname, e)
+        # if e.kind == MODULE_REF and e.fullname not in self.chk.valid_module_references:
+        #    self.chk.encountered.add(e.fullname)
+        #    self.chk.msg.indirect_import(e.fullname, e)
         result = self.analyze_ref_expr(e)
         return self.chk.narrow_type_from_binder(e, result)
 
@@ -861,14 +861,15 @@ def apply_generic_arguments2(self, overload: Overloaded, types: List[Type],
 
     def visit_member_expr(self, e: MemberExpr) -> Type:
         """Visit member expression (of form e.id)."""
-        base = e.expr
-        if isinstance(base, RefExpr) and base.kind == MODULE_REF:
-            self.chk.encountered.add(base.fullname)
-            if base.fullname not in self.chk.valid_module_references:
-                pass
-                #self.chk.msg.indirect_import(base.fullname, e)
+        # base = e.expr
+        # if isinstance(base, RefExpr) and base.kind == MODULE_REF:
+        #     self.chk.encountered.add(base.fullname)
+        #     if base.fullname not in self.chk.valid_module_references:
+        #         pass
+        #         self.chk.msg.indirect_import(base.fullname, e)
         result = self.analyze_ordinary_member_access(e, False)
-        return self.chk.narrow_type_from_binder(e, result)
+        out = self.chk.narrow_type_from_binder(e, result)
+        return out
 
     def analyze_ordinary_member_access(self, e: MemberExpr,
                                        is_lvalue: bool) -> Type:

mypy/fixup.py

@@ -12,8 +12,8 @@
 from mypy.visitor import NodeVisitor
 
 
-def fixup_module_pass_one(tree: MypyFile, modules: Dict[str, MypyFile], valid_references: Optional[Set[str]] = None) -> None:
-    node_fixer = NodeFixer(modules, valid_refs=valid_references, name=tree.fullname())
+def fixup_module_pass_one(tree: MypyFile, modules: Dict[str, MypyFile]) -> None:
+    node_fixer = NodeFixer(modules)
     node_fixer.visit_symbol_table(tree.names)
 
 
@@ -34,12 +34,10 @@ def compute_all_mros(symtab: SymbolTable, modules: Dict[str, MypyFile]) -> None:
 class NodeFixer(NodeVisitor[None]):
     current_info = None  # type: Optional[TypeInfo]
 
-    def __init__(self, modules: Dict[str, MypyFile], type_fixer: 'TypeFixer' = None, valid_refs: Set[str] = None, name: str = None) -> None:
+    def __init__(self, modules: Dict[str, MypyFile], type_fixer: 'TypeFixer' = None) -> None:
         self.modules = modules
-        self.valid_references = valid_refs
-        self.name = name
         if type_fixer is None:
-            type_fixer = TypeFixer(self.modules, self.valid_references, self.name)
+            type_fixer = TypeFixer(self.modules)
         self.type_fixer = type_fixer
 
     # NOTE: This method isn't (yet) part of the NodeVisitor API.
@@ -70,12 +68,6 @@ def visit_symbol_table(self, symtab: SymbolTable) -> None:
         for key, value in list(symtab.items()):
             cross_ref = value.cross_ref
             if cross_ref is not None:  # Fix up cross-reference.
-                original_module = value.cross_ref.rsplit(".", 1)[0]
-                if original_module not in self.valid_references:
-                    if self.name is not None:
-                        print(self.name)
-                        self.name = None
-                    print('    ', cross_ref)
                 del value.cross_ref
                 if cross_ref in self.modules:
                     value.node = self.modules[cross_ref]
@@ -139,22 +131,14 @@ def visit_var(self, v: Var) -> None:
 
 
 class TypeFixer(TypeVisitor[None]):
-    def __init__(self, modules: Dict[str, MypyFile], valid_refs: Set[str] = None, name: str = None) -> None:
+    def __init__(self, modules: Dict[str, MypyFile]) -> None:
         self.modules = modules
-        self.valid_references = valid_refs
-        self.name = name
 
     def visit_instance(self, inst: Instance) -> None:
         # TODO: Combine Instances that are exactly the same?
         type_ref = inst.type_ref
         if type_ref is None:
             return  # We've already been here.
-        original = type_ref.rsplit('.', 1)[0]
-        if original not in self.valid_references:
-            if self.name is not None:
-                print(self.name + ' (type ref)')
-                self.name = None
-            print('    ', type_ref + ' (type ref)')
         del inst.type_ref
         node = lookup_qualified(self.modules, type_ref)
         if isinstance(node, TypeInfo):

mypy/nodes.py

@@ -114,7 +114,7 @@ def get_line(self) -> int:
         return self.line
 
     def accept(self, visitor: NodeVisitor[T]) -> T:
-        raise RuntimeError('Not implemented')
+        raise RuntimeError('Not implemented: {}'.format(self.__class__))
 
 
 # These are placeholders for a future refactoring; see #1783.
@@ -1771,6 +1771,7 @@ class is generic then it will be a type constructor of higher kind.
     """
 
     _fullname = None  # type: str          # Fully qualified name
+    module_name = None  # type: str
     defn = None  # type: ClassDef          # Corresponding ClassDef
     # Method Resolution Order: the order of looking up attributes. The first
     # value always to refers to this class.
@@ -1979,6 +1980,7 @@ def __str__(self) -> str:
     def serialize(self) -> Union[str, JsonDict]:
         # NOTE: This is where all ClassDefs originate, so there shouldn't be duplicates.
         data = {'.class': 'TypeInfo',
+                'module_name': self.module_name,
                 'fullname': self.fullname(),
                 'alt_fullname': self.alt_fullname,
                 'names': self.names.serialize(self.alt_fullname or self.fullname()),
@@ -2003,6 +2005,7 @@ def deserialize(cls, data: JsonDict) -> 'TypeInfo':
         ti = TypeInfo(names, defn)
         ti._fullname = data['fullname']
         ti.alt_fullname = data['alt_fullname']
+        ti.module_name = data['module_name']
         # TODO: Is there a reason to reconstruct ti.subtypes?
         ti.is_abstract = data['is_abstract']
         ti.abstract_attributes = data['abstract_attributes']

mypy/semanal.py

@@ -736,6 +736,7 @@ def setup_class_def_analysis(self, defn: ClassDef) -> None:
         if not defn.info:
             defn.info = TypeInfo(SymbolTable(), defn)
             defn.info._fullname = defn.info.name()
+            defn.info.module_name = self.cur_mod_id
         if self.is_func_scope() or self.type:
             kind = MDEF
             if self.is_func_scope():
@@ -1384,6 +1385,7 @@ def build_newtype_typeinfo(self, name: str, old_type: Type, base_type: Instance)
 
         symbols = SymbolTable()
         info = TypeInfo(symbols, class_def)
+        info.module_name = self.cur_mod_id
         info.mro = [info] + base_type.type.mro
         info.bases = [base_type]
         info.is_newtype = True
@@ -1657,6 +1659,7 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str],
         class_def = ClassDef(name, Block([]))
         class_def.fullname = self.qualified_name(name)
         info = TypeInfo(symbols, class_def)
+        info.module_name = self.cur_mod_id
         # Add named tuple items as attributes.
         # TODO: Make them read-only.
         for item, typ in zip(items, types):
@@ -2577,6 +2580,7 @@ def visit_class_def(self, cdef: ClassDef) -> None:
         self.sem.check_no_global(cdef.name, cdef)
         cdef.fullname = self.sem.qualified_name(cdef.name)
         info = TypeInfo(SymbolTable(), cdef)
+        info.module_name = self.sem.cur_mod_id
         info.set_line(cdef.line)
         cdef.info = info
         self.sem.globals[cdef.name] = SymbolTableNode(GDEF, info,
@@ -2591,6 +2595,8 @@ def process_nested_classes(self, outer_def: ClassDef) -> None:
                     node.info._fullname = outer_def.fullname + '.' + node.info.name()
                 else:
                     node.info._fullname = node.info.name()
+                node.info.module_name = self.sem.cur_mod_id
+                node.fullname = node.info._fullname
                 symbol = SymbolTableNode(MDEF, node.info)
                 outer_def.info.names[node.name] = symbol
                 self.process_nested_classes(node)

mypy/test/testcheck.py

@@ -88,6 +88,7 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
             # We briefly sleep to make sure file timestamps are distinct.
             self.clear_cache()
             self.run_case_once(testcase, 1)
+            print('\n----\n')
             self.run_case_once(testcase, 2)
         elif optional:
             try:

test-data/unit/check-incremental.test

@@ -298,7 +298,7 @@ const = 3
 # Import to mod4 is gone!
 
 [rechecked mod1, mod2, mod3]
-[stale mod1, mod2, mod3]
+[stale mod3]
 [builtins fixtures/module.pyi]
 [out]
 main:1: note: In module imported here:
@@ -324,7 +324,8 @@ const = 3
 [file mod4.py.next]
 const = "foo"
 
-[stale mod1, mod2, mod3, mod4]
+[rechecked mod1, mod3, mod4]
+[stale mod4]
 [out]
 main:1: note: In module imported here:
 tmp/mod1.py:3: error: Argument 1 to "accepts_int" has incompatible type "str"; expected "int"
@@ -375,7 +376,7 @@ def func2() -> str:
     return "foo"
 
 [rechecked mod0, mod1, mod2]
-[stale mod0, mod2]
+[stale mod2]
 [out]
 tmp/mod0.py:1: note: In module imported here,
 main:1: note: ... from here:
@@ -878,7 +879,7 @@ tmp/main.py:4: error: "Class" has no attribute "some_attribute"
 [case testIncrementalWithIgnores]
 import foo # type: ignore
 
-[builtins fixtures/args.pyi]
+[builtins fixtures/module.pyi]
 [stale]
 [out]
 
@@ -930,7 +931,7 @@ class A:
 class A:
   pass
 [rechecked m, n]
-[stale m, n]
+[stale n]
 [out]
 
 [case testIncrementalReplacingImports]

test-data/unit/check-modules.test

@@ -277,6 +277,7 @@ main:1: note: (Perhaps setting MYPYPATH or using the "--silent-imports" flag wou
 import xyz, bar
 xyz.foo()
 bar()
+[builtins fixtures/args.pyi]
 [out]
 main:1: error: Cannot find module named 'xyz'
 main:1: note: (Perhaps setting MYPYPATH or using the "--silent-imports" flag would help)

test-data/unit/fixtures/args.pyi

@@ -26,3 +26,4 @@ class int:
 class str: pass
 class bool: pass
 class function: pass
+class module: pass

test-data/unit/fixtures/module.pyi

@@ -5,3 +5,4 @@ class type: pass
 class function: pass
 class int: pass
 class str: pass
+class tuple: pass