tighten lvalues for binder

python · elazarg · Sep 3, 2016 · Oct 2, 2016 · Oct 5, 2016 · Oct 5, 2016
commit f6bdc207c17bb6fd7e5e08dcf993f4df1400b2cc
diff --git a/mypy/binder.py b/mypy/binder.py
@@ -1,3 +1,4 @@
+from builtins import type as realtype
 from typing import (Any, Dict, List, Set, Iterator, Union)
 from contextlib import contextmanager
 
@@ -8,15 +9,20 @@
    from mypy.join import join_simple
 from mypy.sametypes import is_same_type
 
+from mypy.nodes import IndexExpr, MemberExpr, NameExpr, SuperExpr
 
-class Frame(Dict[Any, Type]):
-    pass
+
+BLval = Union[IndexExpr, MemberExpr, NameExpr]
 
 
 class Key(AnyType):
     pass
 
 
+class Frame(Dict[Key, Type]):
+    pass
+
+
 class ConditionalTypeBinder:
     """Keep track of conditional types of variables.
 
@@ -97,6 +103,7 @@ def _get(self, key: Key, index: int=-1) -> Type:
         return None
 
     def push(self, expr: Expression, typ: Type) -> None:
+        assert isinstance(expr, (IndexExpr, MemberExpr, NameExpr))
         if not expr.literal:
             return
         key = expr.literal_hash
@@ -105,11 +112,16 @@ def push(self, expr: Expression, typ: Type) -> None:
             self._add_dependencies(key)
         self._push(key, typ)
 
-    def get(self, expr: Union[Expression, Var]) -> Type:
+    def get(self, expr: Union[BLval, Var]) -> Type:
+        assert isinstance(expr, BLval.__union_params__ + (Var,))
+        if isinstance(expr, Var):
+            # where is this literal hash initialized?
+            return self._get(expr.literal_hash)
         return self._get(expr.literal_hash)
 
-    def cleanse(self, expr: Expression) -> None:
+    def cleanse(self, expr: BLval) -> None:
         """Remove all references to an Expression from the binder."""
+        assert isinstance(expr, BLval.__union_params__)
         self._cleanse_key(expr.literal_hash)
 
     def _cleanse_key(self, key: Key) -> None:
@@ -165,7 +177,8 @@ def pop_frame(self, fall_through: int = 0) -> Frame:
 
         return result
 
-    def get_declaration(self, expr: Expression) -> Type:
+    def get_declaration(self, expr: BLval) -> Type:
+        assert isinstance(expr, BLval.__union_params__)
         if isinstance(expr, (RefExpr, SymbolTableNode)) and isinstance(expr.node, Var):
             type = expr.node.type
             if isinstance(type, PartialType):
@@ -174,11 +187,12 @@ def get_declaration(self, expr: Expression) -> Type:
         else:
             return None
 
-    def assign_type(self, expr: Expression,
+    def assign_type(self, expr: Union[BLval, SuperExpr],
                     type: Type,
                     declared_type: Type,
                     restrict_any: bool = False) -> None:
-        if not expr.literal:
+        assert isinstance(expr, BLval.__union_params__ + (SuperExpr,))
+        if isinstance(expr, SuperExpr) or not expr.literal:
             return
         self.invalidate_dependencies(expr)
 
@@ -211,7 +225,8 @@ def assign_type(self, expr: Expression,
             # just copy this variable into a single stored frame.
             self.allow_jump(i)
 
-    def invalidate_dependencies(self, expr: Expression) -> None:
+    def invalidate_dependencies(self, expr: BLval) -> None:
+        assert isinstance(expr, BLval.__union_params__)
         """Invalidate knowledge of types that include expr, but not expr itself.
 
         For example, when expr is foo.bar, invalidate foo.bar.baz.
@@ -222,7 +237,8 @@ def invalidate_dependencies(self, expr: Expression) -> None:
         for dep in self.dependencies.get(expr.literal_hash, set()):
             self._cleanse_key(dep)
 
-    def most_recent_enclosing_type(self, expr: Expression, type: Type) -> Type:
+    def most_recent_enclosing_type(self, expr: BLval, type: Type) -> Type:
+        assert isinstance(expr, BLval.__union_params__)
         if isinstance(type, AnyType):
             return self.get_declaration(expr)
         key = expr.literal_hash

diff --git a/mypy/checker.py b/mypy/checker.py
@@ -1081,6 +1081,7 @@ def check_assignment(self, lvalue: Lvalue, rvalue: Expression, infer_lvalue_type
                     rvalue_type = self.check_simple_assignment(lvalue_type, rvalue, lvalue)
 
                 if rvalue_type and infer_lvalue_type:
+                    assert isinstance(lvalue, (IndexExpr, MemberExpr, NameExpr, SuperExpr))
                     self.binder.assign_type(lvalue,
                                             rvalue_type,
                                             lvalue_type,
@@ -1378,7 +1379,8 @@ def set_inference_error_fallback_type(self, var: Var, lvalue: Lvalue, type: Type
         if context.get_line() in self.errors.ignored_lines[self.errors.file]:
             self.set_inferred_type(var, lvalue, AnyType())
 
-    def narrow_type_from_binder(self, expr: Expression, known_type: Type) -> Type:
+    def narrow_type_from_binder(self, expr: Union[IndexExpr, MemberExpr, NameExpr],
+                                known_type: Type) -> Type:
         if expr.literal >= LITERAL_TYPE:
             restriction = self.binder.get(expr)
             if restriction: