Fix a handful of fine-grained incremental bugs (python#4691)

msullivan · web-flow · commit 9c0097860696 · 2018-03-07T09:43:40.000-08:00
* Fix refresh of implicit tuple types
* Fix refresh of imports in if MYPY else blocks
* Fix astmerge of CastExpr
diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
@@ -51,6 +51,7 @@
     Node, MypyFile, SymbolTable, Block, AssignmentStmt, NameExpr, MemberExpr, RefExpr, TypeInfo,
     FuncDef, ClassDef, NamedTupleExpr, SymbolNode, Var, Statement, SuperExpr, NewTypeExpr,
     OverloadedFuncDef, LambdaExpr, TypedDictExpr, EnumCallExpr, FuncBase, TypeAliasExpr, CallExpr,
+    CastExpr,
     MDEF
 )
 from mypy.traverser import TraverserVisitor
@@ -217,6 +218,10 @@ def visit_namedtuple_expr(self, node: NamedTupleExpr) -> None:
         node.info = self.fixup_and_reset_typeinfo(node.info)
         self.process_synthetic_type_info(node.info)
 
+    def visit_cast_expr(self, node: CastExpr) -> None:
+        super().visit_cast_expr(node)
+        self.fixup_type(node.type)
+
     def visit_super_expr(self, node: SuperExpr) -> None:
         super().visit_super_expr(node)
         if node.info is not None:
@@ -366,7 +371,9 @@ def visit_partial_type(self, typ: PartialType) -> None:
     def visit_tuple_type(self, typ: TupleType) -> None:
         for item in typ.items:
             item.accept(self)
-        typ.fallback.accept(self)
+        # Fallback can be None for implicit tuple types that haven't been semantically analyzed.
+        if typ.fallback is not None:
+            typ.fallback.accept(self)
 
     def visit_type_type(self, typ: TypeType) -> None:
         typ.item.accept(self)
diff --git a/mypy/server/aststrip.py b/mypy/server/aststrip.py
@@ -159,6 +159,8 @@ def visit_import_from(self, node: ImportFrom) -> None:
         if node.assignments:
             node.assignments = []
         else:
+            # If the node is unreachable, don't reset entries: they point to something else!
+            if node.is_unreachable: return
             if self.names:
                 # Reset entries in the symbol table. This is necessary since
                 # otherwise the semantic analyzer will think that the import
@@ -173,6 +175,8 @@ def visit_import(self, node: Import) -> None:
         if node.assignments:
             node.assignments = []
         else:
+            # If the node is unreachable, don't reset entries: they point to something else!
+            if node.is_unreachable: return
             if self.names:
                 # Reset entries in the symbol table. This is necessary since
                 # otherwise the semantic analyzer will think that the import
diff --git a/test-data/unit/fine-grained-modules.test b/test-data/unit/fine-grained-modules.test
@@ -1089,3 +1089,23 @@ def foo(x: int) -> None: pass
 ==
 a.py:2: error: Too many arguments for "foo"
 ==
+
+[case testRefreshImportIfMypyElse1]
+import a
+[file a.py]
+from b import foo
+
+MYPY = False
+if MYPY:
+    x = 0
+else:
+    from fictional import x
+
+x = 1
+[file b/__init__.py]
+[file b/foo.py]
+[file b/__init__.py.2]
+# Dummy change
+[builtins fixtures/bool.pyi]
+[out]
+==
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
@@ -2635,3 +2635,84 @@ def a(f: Callable[[Arg(int, 'x')], int]) -> None: pass
 [builtins fixtures/dict.pyi]
 [out]
 ==
+
+[case testImplicitTuple1]
+import a
+[file a.py]
+# Bogus annotation in nested function masked because outer function
+# isn't annotated
+def unchecked():
+    def inner():
+        # type: () -> (str, int)
+        return 'lol', 10
+[file a.py.2]
+# dummy change
+def unchecked():
+    def inner():
+        # type: () -> (str, int)
+        return 'lol', 10
+[out]
+==
+
+[case testImplicitTuple2]
+import a
+[file a.py]
+def inner():
+    # type: () -> (str, int)
+    return 'lol', 10
+[file a.py.2]
+# dummy change
+def inner():
+    # type: () -> (str, int)
+    return 'lol', 10
+[out]
+a.py:1: error: Invalid tuple literal type
+==
+a.py:2: error: Invalid tuple literal type
+
+[case testImplicitTuple3]
+import a
+[file a.py]
+(x, y) = 1, 'hi'  # type: (int, str)
+[file a.py.2]
+# dummy change
+(x, y) = 1, 'hi'  # type: (int, str)
+[out]
+==
+
+[case testCastConfusion]
+import b
+[file a.py]
+from typing import cast
+class Thing:
+    def foo(self) -> None: pass
+
+thing = cast(Thing, Thing())
+
+[file b.py]
+from typing import Optional
+from a import Thing, thing
+class User:
+    def __init__(self, x: Optional[Thing]) -> None:
+        self.x = x if x else thing
+    def use(self) -> None: self.x.foo()
+
+[file a.py.2]
+from typing import cast
+class Thing:
+    def foo(self) -> None: pass
+
+thing = cast(Thing, Thing())
+# update
+
+[file b.py.2]
+from typing import Optional
+from a import Thing, thing
+class User:
+    def __init__(self, x: Optional[Thing]) -> None:
+        self.x = x if x else thing
+    def use(self) -> None: self.x.foo()
+# update
+[builtins fixtures/ops.pyi]
+[out]
+==
diff --git a/test-data/unit/merge.test b/test-data/unit/merge.test
@@ -1395,3 +1395,30 @@ TypeInfo<2>(
   Bases(builtins.type<3>)
   Mro(target.M<2>, builtins.type<3>, builtins.object<1>)
   Names())
+
+[case testCast_symtable]
+import target
+[file target.py]
+from typing import cast
+class Thing:
+    pass
+thing = cast(Thing, Thing())
+[file target.py.next]
+from typing import cast
+class Thing:
+    pass
+thing = cast(Thing, Thing())
+[out]
+__main__:
+    target: MypyFile<0>
+target:
+    Thing: TypeInfo<1>
+    cast: Var<2>
+    thing: Var<3>(target.Thing<1>)
+==>
+__main__:
+    target: MypyFile<0>
+target:
+    Thing: TypeInfo<1>
+    cast: Var<2>
+    thing: Var<3>(target.Thing<1>)
