WIP 3

Author: MichaelLeeDBX

mypy/build.py

@@ -1420,7 +1420,8 @@ def type_check(self) -> None:
         if manager.options.semantic_analysis_only:
             return
         with self.wrap_context():
-            manager.type_checker.type_map = {}
+            manager.type_checker.module_type_map = {}
+            manager.type_checker.module_refs = set()
             manager.type_checker.visit_file(self.tree, self.xpath, set())
             # encountered = manager.type_checker.get_encountered()
             # print(manager.type_checker.type_map)
@@ -1431,15 +1432,25 @@ def type_check(self) -> None:
             manager.report_file(self.tree)
 
     def detect_indirection(self) -> None:
+        # print(self.id)
         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)
+        # count = 0
+        vals = self.manager.type_checker.module_type_map
+        self.manager.indirection_detector.type_visitor.count = 0
+        for item, val in self.manager.type_checker.module_type_map.items():
+            # self.manager.indirection_detector._visit(item)
             self.manager.indirection_detector._visit_types(val)
 
-        encountered = self.manager.indirection_detector.modules
+        module_refs = self.manager.type_checker.module_refs
+        encountered = self.manager.indirection_detector.modules | module_refs
         valid = self.valid_references()
         extra = encountered - valid
+        # print('    found', encountered)
+        # print('    valid', valid)
+        # print('    extra', extra)
+        # print('    # checked', count)
+        # print()
         for dep in extra:
             self.dependencies.append(dep)
             self.priorities[dep] = PRI_INDIRECT

mypy/checker.py

@@ -86,6 +86,7 @@ class TypeChecker(NodeVisitor[Type]):
     msg = None  # type: MessageBuilder
     # Types of type checked nodes
     type_map = None  # type: Dict[Node, Type]
+    module_type_map = None  # type: Dict[Node, Type]
 
     # Helper for managing conditional types
     binder = None  # type: ConditionalTypeBinder
@@ -122,6 +123,8 @@ class TypeChecker(NodeVisitor[Type]):
     # not be modified.
     valid_module_references = None  # type: Optional[Set[str]]
 
+    module_refs = None  # type: Set[str]
+
     def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Options) -> None:
         """Construct a type checker.
 
@@ -132,6 +135,7 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Option
         self.options = options
         self.msg = MessageBuilder(errors, modules)
         self.type_map = {}
+        self.module_type_map = {}
         self.binder = ConditionalTypeBinder()
         self.expr_checker = mypy.checkexpr.ExpressionChecker(self, self.msg)
         self.return_types = []
@@ -144,6 +148,7 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Option
         self.pass_num = 0
         self.current_node_deferred = False
         self.encountered = set()  # type: Set[str]
+        self.module_refs = set()
 
     def get_encountered(self) -> Set[str]:
         return self.encountered
@@ -2197,6 +2202,7 @@ def check_type_equivalency(self, t1: Type, t2: Type, node: Context,
     def store_type(self, node: Node, typ: Type) -> None:
         """Store the type of a node in the type map."""
         self.type_map[node] = typ
+        self.module_type_map[node] = typ
 
     def typing_mode_none(self) -> bool:
         if self.is_dynamic_function() and not self.options.check_untyped_defs:

mypy/checkexpr.py

@@ -1,6 +1,6 @@
 """Expression type checker. This file is conceptually part of TypeChecker."""
 
-from typing import cast, Dict, Set, List, Tuple, Callable, Union, Optional
+from typing import cast, Dict, Set, List, Iterable, Tuple, Callable, Union, Optional
 
 from mypy.types import (
     Type, AnyType, CallableType, Overloaded, NoneTyp, Void, TypeVarDef,
@@ -16,7 +16,7 @@
     ListComprehension, GeneratorExpr, SetExpr, MypyFile, Decorator,
     ConditionalExpr, ComparisonExpr, TempNode, SetComprehension,
     DictionaryComprehension, ComplexExpr, EllipsisExpr, StarExpr,
-    TypeAliasExpr, BackquoteExpr, ARG_POS, ARG_NAMED, ARG_STAR2, MODULE_REF,
+    TypeAliasExpr, BackquoteExpr, ARG_POS, ARG_NAMED, ARG_STAR2, MODULE_REF, node_kinds,
 )
 from mypy.nodes import function_type
 from mypy import nodes
@@ -45,6 +45,45 @@
                       None]
 
 
+def split_module_names(mod_name: str) -> Iterable[str]:
+    yield mod_name
+    while '.' in mod_name:
+        mod_name = mod_name.rsplit('.', 1)[0]
+        yield mod_name
+
+
+def extract_module_names(symbol_name: str) -> Iterable[str]:
+    if symbol_name is None or '.' not in symbol_name:
+        return
+        # raise RuntimeError("{} is not a qualified symbol name".format(symbol_name))
+    else:
+        while '.' in symbol_name:
+            symbol_name = symbol_name.rsplit('.', 1)[0]
+            yield symbol_name
+
+
+def extract_refexpr_names(expr: RefExpr) -> Set[str]:
+    output = set()  # type: Set[str]
+    while expr.kind == MODULE_REF or expr.fullname is not None:
+        if expr.kind == MODULE_REF:
+            output.add(expr.fullname)
+        elif expr.fullname is not None and '.' in expr.fullname:
+            output.add(expr.fullname.rsplit('.', 1)[0])
+
+        if isinstance(expr, NameExpr):
+            if expr.info is not None:
+                output.update(split_module_names(expr.info.module_name))
+            break
+        elif isinstance(expr, MemberExpr):
+            if isinstance(expr.expr, RefExpr):
+                expr = expr.expr
+            else:
+                break
+        else:
+            raise AssertionError("Unknown RefExpr subclass: {}".format(type(expr)))
+    return output
+
+
 class Finished(Exception):
     """Raised if we can terminate overload argument check early (no match)."""
 
@@ -70,6 +109,12 @@ def __init__(self,
         self.msg = msg
         self.strfrm_checker = StringFormatterChecker(self, self.chk, self.msg)
 
+    def _visit_typeinfo(self, info: nodes.TypeInfo) -> None:
+        if info is not None:
+            # self._add_symbol(info.fullname())
+            self.chk.module_refs.update(split_module_names(info.module_name))
+            # self._visit_symboltable(info.names)
+
     def visit_name_expr(self, e: NameExpr) -> Type:
         """Type check a name expression.
 
@@ -78,8 +123,17 @@ def visit_name_expr(self, e: NameExpr) -> Type:
         # 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:
+        #     self.chk.module_refs.add(e.fullname)
+        # elif e.fullname is not None:  # and '.' in expr.fullname:
+        #     self.chk.module_refs.update(extract_module_names(e.fullname))
+        # self._visit_typeinfo(e.info)'''
         result = self.analyze_ref_expr(e)
-        return self.chk.narrow_type_from_binder(e, result)
+        out = self.chk.narrow_type_from_binder(e, result)
+
+        self.chk.module_refs.update(extract_refexpr_names(e))
+
+        return out
 
     def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
         result = None  # type: Type
@@ -867,8 +921,17 @@ def visit_member_expr(self, e: MemberExpr) -> Type:
         #     if base.fullname not in self.chk.valid_module_references:
         #         pass
         #         self.chk.msg.indirect_import(base.fullname, e)
+        # if isinstance(e, nodes.RefExpr) and e.kind == MODULE_REF:
+        #     print('A', e, e.fullname, e.name)
+        #     self.chk.module_refs.add(e.fullname)
+        # else:
+        #     print('B', e, e.fullname, e.name)
+        #     self.chk.module_refs.update(extract_module_names(e.fullname))
         result = self.analyze_ordinary_member_access(e, False)
         out = self.chk.narrow_type_from_binder(e, result)
+
+        self.chk.module_refs.update(extract_refexpr_names(e))
+
         return out
 
     def analyze_ordinary_member_access(self, e: MemberExpr,

mypy/test/testcheck.py

@@ -88,7 +88,6 @@ 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

@@ -304,6 +304,68 @@ const = 3
 main:1: note: In module imported here:
 tmp/mod1.py:3: error: "module" has no attribute "mod4"
 
+[case testIncrementalLongBrokenCascade]
+import mod1
+
+[file mod1.py]
+import mod2
+def accept_int(a: int) -> int: return a
+accept_int(mod2.mod3.mod4.mod5.mod6.mod7.const)
+
+[file mod2.py]
+import mod3
+
+[file mod3.py]
+import mod4
+
+[file mod4.py]
+import mod5
+
+[file mod5.py]
+import mod6
+
+[file mod6.py]
+import mod7
+
+[file mod7.py]
+const = 3
+
+[file mod6.py.next]
+# Import to mod7 is gone!
+
+[rechecked mod1, mod5, mod6]
+[stale mod6]
+[builtins fixtures/module.pyi]
+[out]
+main:1: note: In module imported here:
+tmp/mod1.py:3: error: "module" has no attribute "mod7"
+
+[case testIncrementalNestedBrokenCascade]
+import mod1
+
+[file mod1.py]
+import mod2
+def accept_int(a: int) -> int: return a
+accept_int(mod2.mod3.mod4.const)
+
+[file mod2/__init__.py]
+import mod2.mod3 as mod3
+
+[file mod2/mod3/__init__.py]
+import mod2.mod3.mod4 as mod4
+
+[file mod2/mod3/mod4.py]
+const = 3
+
+[file mod2/mod3/__init__.py.next]
+# Import is gone!
+
+[rechecked mod1, mod2, mod2.mod3]
+[stale mod2.mod3]
+[out]
+main:1: note: In module imported here:
+tmp/mod1.py:3: error: "module" has no attribute "mod4"
+
 [case testIncrementalRemoteChange]
 import mod1
 
@@ -960,3 +1022,36 @@ foo(3)
 [out]
 main:1: note: In module imported here:
 tmp/client.py:4: error: Argument 1 to "foo" has incompatible type "int"; expected "str"
+
+[case testIncrementalChangingAlias]
+import m1, m2, m3, m4, m5
+
+[file m1.py]
+from m2 import A
+def accepts_int(x: int) -> None: pass
+accepts_int(A())
+
+[file m2.py]
+from m3 import A
+
+[file m3.py]
+from m4 import B
+A = B
+
+[file m3.py.next]
+from m5 import C
+A = C
+
+[file m4.py]
+def B() -> int:
+    return 42
+
+[file m5.py]
+def C() -> str:
+    return "hello"
+
+[rechecked m1, m2, m3]
+[stale m3]
+[out]
+main:1: note: In module imported here:
+tmp/m1.py:3: error: Argument 1 to "accepts_int" has incompatible type "str"; expected "int"