Fix special cases

JukkaL · Jan 21, 2019 · Sep 20, 2018 · Sep 20, 2018 · Sep 20, 2018 · Sep 20, 2018
commit 35f56ae983e744325b60026b9865818aba8eb6e5
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -373,9 +373,17 @@ def file_context(self, file_node: MypyFile, fnam: str, options: Options,
     def visit_func_def(self, defn: FuncDef) -> None:
         if not self.recurse_into_functions:
             return
+
+        # Conservatively do not allow variable defined before a function to
+        # be redefined later, since function could refer to either definition.
+        self.var_def_analyzer.reject_redefinition_of_vars_in_scope()
+        self.var_def_analyzer.enter_scope()
+
         with self.scope.function_scope(defn):
             self._visit_func_def(defn)
 
+        self.var_def_analyzer.leave_scope()
+
     def _visit_func_def(self, defn: FuncDef) -> None:
         phase_info = self.postpone_nested_functions_stack[-1]
         if phase_info != FUNCTION_SECOND_PHASE:
@@ -2666,7 +2674,9 @@ def visit_try_stmt(self, s: TryStmt) -> None:
 
     def analyze_try_stmt(self, s: TryStmt, visitor: NodeVisitor[None],
                          add_global: bool = False) -> None:
+        self.var_def_analyzer.enter_with_or_try()
         s.body.accept(visitor)
+        self.var_def_analyzer.leave_with_or_try()
         for type, var, handler in zip(s.types, s.vars, s.handlers):
             if type:
                 type.accept(visitor)
@@ -2723,7 +2733,9 @@ def visit_with_stmt(self, s: WithStmt) -> None:
             elif isinstance(s.target_type, TupleType):
                 s.target_type = s.target_type.copy_modified(items=new_types)
 
+        self.var_def_analyzer.enter_with_or_try()
         self.visit_block(s.body)
+        self.var_def_analyzer.leave_with_or_try()
 
     def visit_del_stmt(self, s: DelStmt) -> None:
         s.expr.accept(self)

diff --git a/mypy/semanal_shared.py b/mypy/semanal_shared.py
@@ -166,12 +166,13 @@ class VarDefAnalyzer:
 
     def __init__(self) -> None:
         self.block_id = 0
+        self.disallow_redef_depth = 0
         self.blocks = []  # type: List[int]
-        self.var_blocks = {}  # type: Dict[str, int]
+        self.var_blocks = [{}]  # type: List[Dict[str, int]]
 
     def clear(self) -> None:
         self.blocks = []
-        self.var_blocks = {}
+        self.var_blocks = [{}]
 
     def enter_block(self) -> None:
         self.block_id += 1
@@ -180,37 +181,47 @@ def enter_block(self) -> None:
     def leave_block(self) -> None:
         self.blocks.pop()
 
+    def enter_with_or_try(self) -> None:
+        self.disallow_redef_depth += 1
+
+    def leave_with_or_try(self) -> None:
+        self.disallow_redef_depth -= 1
+
     def current_block(self) -> int:
         return self.blocks[-1]
 
     def enter_scope(self) -> None:
-        pass  # TODO
+        self.var_blocks.append({})
 
     def leave_scope(self) -> None:
-        pass  # TODO
+        self.var_blocks.pop()
 
     def reject_redefinition_of_vars_in_scope(self) -> None:
         """Make it impossible to redefine defined variables in the current scope.
 
         This is used if we encounter a function definition or break/continue that
         can make it ambiguous which definition is live.
         """
-        for key in self.var_blocks:
-            self.var_blocks[key] = -1
+        var_blocks = self.var_blocks[-1]
+        for key in var_blocks:
+            var_blocks[key] = -1
 
     def process_assignment(self, name: str, can_be_redefined: bool) -> bool:
         """Record assignment to given name and return True if it defines a new name."""
+        if self.disallow_redef_depth > 0:
+            can_be_redefined = False
         block = self.current_block()
-        if name not in self.var_blocks:
+        var_blocks = self.var_blocks[-1]
+        if name not in var_blocks:
             # New definition
             if can_be_redefined:
-                self.var_blocks[name] = block
+                var_blocks[name] = block
             else:
                 # This doesn't support arbitrary redefinition.
                 # TODO: Make this less restricted.
-                self.var_blocks[name] = -1
+                var_blocks[name] = -1
             return True
-        elif self.var_blocks[name] == block:
+        elif var_blocks[name] == block:
             # Redefinition
             return True
         else:

diff --git a/test-data/unit/check-redefine.test b/test-data/unit/check-redefine.test
@@ -1,23 +1,26 @@
--- Redefinition of variable with a different type
--- ----------------------------------------------
+-- Test cases for the redefinition of variable with a different type.
+
+
+-- Redefine local variable
+-- -----------------------
 
 
 [case testRedefineLocalWithDifferentType]
 def f() -> None:
     x = 0
-    reveal_type(x)  # E: Revealed type is 'builtins.int'
+    reveal_type(x) # E: Revealed type is 'builtins.int'
     x = ''
-    reveal_type(x)  # E: Revealed type is 'builtins.str'
+    reveal_type(x) # E: Revealed type is 'builtins.str'
 
 [case testCannotConditionallyRedefineLocalWithDifferentType]
 def f() -> None:
     y = 0
-    reveal_type(y)  # E: Revealed type is 'builtins.int'
+    reveal_type(y) # E: Revealed type is 'builtins.int'
     if int():
         y = ''  \
         # E: Incompatible types in assignment (expression has type "str", variable has type "int")
         reveal_type(y)  # E: Revealed type is 'builtins.int'
-    reveal_type(y)  # E: Revealed type is 'builtins.int'
+    reveal_type(y) # E: Revealed type is 'builtins.int'
 
 [case testRedefineFunctionArg]
 def f(x: int) -> None:
@@ -33,9 +36,9 @@ def f() -> None:
     x: int
     x = '' \
         # E: Incompatible types in assignment (expression has type "str", variable has type "int")
-    reveal_type(x)  # E: Revealed type is 'builtins.int'
+    reveal_type(x) # E: Revealed type is 'builtins.int'
 def g() -> None:
-    x: int  # This syntax prevents redefinition through assignment
+    x: int # This syntax prevents redefinition through assignment
     x = 1
     x = '' \
         # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -53,3 +56,96 @@ def f(x: int) -> None:
     reveal_type(y)  # E: Revealed type is 'Union[builtins.int*, builtins.str]'
 
 def g(x: T) -> Union[T, str]: pass
+
+[case testRedefineLocalForLoopIndexVariable]
+from typing import Iterable
+def f(a: Iterable[int], b: Iterable[str]) -> None:
+    for x in a:
+        x = '' \
+        # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    reveal_type(x) # E: Revealed type is 'builtins.int*'
+    for x in b:
+        x = 1 \
+        # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    reveal_type(x) # E: Revealed type is 'builtins.str*'
+
+def g(a: Iterable[int]) -> None:
+    for x in a: pass
+    x = ''
+
+def h(a: Iterable[int]) -> None:
+    x = ''
+    for x in a: pass
+
+[case testCannotRedefineLocalWithinTry]
+def f() -> None:
+    try:
+        x = 0
+        g()  # Might raise an exception
+        x = '' \
+        # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    except:
+        pass
+    reveal_type(x) # E: Revealed type is 'builtins.int'
+    y = 0
+    y = ''
+
+def g(): pass
+
+[case testCannotRedefineLocalWithinWith]
+def f() -> None:
+    with g():
+        x = 0
+        g()  # Might raise an exception
+        x = '' \
+        # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    reveal_type(x) # E: Revealed type is 'builtins.int'
+    y = 0
+    y = ''
+
+def g(): pass
+
+[case testCannotRedefineAcrossNestedFunction]
+def f() -> None:
+    x = 0
+    def g() -> None:
+        x
+    g()
+    x = '' \
+    # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    g()
+    y = 0
+    y = ''
+
+[case testCannotRedefineAcrossNestedDecoratedFunction]
+def dec(f): return f
+
+def f() -> None:
+    x = 0
+    @dec
+    def g() -> None:
+        x
+    g()
+    x = '' \
+    # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    g()
+    y = 0
+    y = ''
+
+[case testCannotRedefineAcrossNestedOverloadedFunction]
+from typing import overload
+
+def f() -> None:
+    x = 0
+    @overload
+    def g() -> None: pass
+    @overload
+    def g(x: int) -> None: pass
+    def g(x=0):
+        pass
+    g()
+    x = '' \
+    # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    g()
+    y = 0
+    y = ''