rename binder api

python · gvanrossum · Mar 27, 2017 · Oct 6, 2016 · Oct 10, 2016 · Oct 10, 2016
commit d01d2f1cd9ac9175767be25a739e92bdffe04eb1
diff --git a/mypy/binder.py b/mypy/binder.py
@@ -1,19 +1,24 @@
-from typing import (Any, Dict, List, Set, Iterator, Union)
+from typing import (Dict, List, Set, Iterator, Union)
 from contextlib import contextmanager
 
 from mypy.types import Type, AnyType, PartialType
-from mypy.nodes import (Node, Expression, Var, RefExpr, SymbolTableNode)
+from mypy.nodes import (Node as Expression, Var, RefExpr, SymbolTableNode)
 
 from mypy.subtypes import is_subtype
 from mypy.join import join_simple
 from mypy.sametypes import is_same_type
 
+from mypy.nodes import IndexExpr, MemberExpr, NameExpr
+
+
+BindableTypes = (IndexExpr, MemberExpr, NameExpr)
+BindableExpression = Union[IndexExpr, MemberExpr, NameExpr]
 
-class Frame(Dict[Any, Type]):
-    pass
 
+Key = object
 
-class Key(AnyType):
+
+class Frame(Dict[object, Type]):
     pass
 
 
@@ -85,7 +90,7 @@ def push_frame(self) -> Frame:
         self.options_on_return.append([])
         return f
 
-    def _push(self, key: Key, type: Type, index: int=-1) -> None:
+    def _put(self, key: Key, type: Type, index: int=-1) -> None:
         self.frames[index][key] = type
 
     def _get(self, key: Key, index: int=-1) -> Type:
@@ -96,20 +101,24 @@ def _get(self, key: Key, index: int=-1) -> Type:
                 return self.frames[i][key]
         return None
 
-    def push(self, node: Node, typ: Type) -> None:
-        if not node.literal:
+    def put_if_bindable(self, expr: Expression, typ: Type) -> None:
+        if not isinstance(expr, BindableTypes):
+            return
+        if not expr.literal:
             return
-        key = node.literal_hash
+        key = expr.literal_hash
         if key not in self.declarations:
-            self.declarations[key] = self.get_declaration(node)
+            self.declarations[key] = self.get_declaration(expr)
             self._add_dependencies(key)
-        self._push(key, typ)
+        self._put(key, typ)
 
-    def get(self, expr: Union[Expression, Var]) -> Type:
+    def get(self, expr: Expression) -> Type:
+        if not isinstance(expr, BindableTypes):
+            return None
         return self._get(expr.literal_hash)
 
-    def cleanse(self, expr: Expression) -> None:
-        """Remove all references to a Node from the binder."""
+    def cleanse(self, expr: BindableExpression) -> None:
+        """Remove all references to an Expression from the binder."""
         self._cleanse_key(expr.literal_hash)
 
     def _cleanse_key(self, key: Key) -> None:
@@ -144,7 +153,7 @@ def update_from_options(self, frames: List[Frame]) -> bool:
                 for other in resulting_values[1:]:
                     type = join_simple(self.declarations[key], type, other)
             if not is_same_type(type, current_value):
-                self._push(key, type)
+                self._put(key, type)
                 changed = True
 
         return changed
@@ -165,19 +174,20 @@ def pop_frame(self, fall_through: int = 0) -> Frame:
 
         return result
 
-    def get_declaration(self, node: Node) -> Type:
-        if isinstance(node, (RefExpr, SymbolTableNode)) and isinstance(node.node, Var):
-            type = node.node.type
-            if isinstance(type, PartialType):
-                return None
-            return type
-        else:
-            return None
+    def get_declaration(self, expr: BindableExpression) -> Type:
+        assert not isinstance(expr, SymbolTableNode)
+        if isinstance(expr, RefExpr) and isinstance(expr.node, Var):
+            type = expr.node.type
+            if not isinstance(type, PartialType):
+                return type
+        return None
 
-    def assign_type(self, expr: Expression,
-                    type: Type,
-                    declared_type: Type,
-                    restrict_any: bool = False) -> None:
+    def assign_type_if_bindable(self, expr: Expression,
+                                type: Type,
+                                declared_type: Type,
+                                restrict_any: bool = False) -> None:
+        if not isinstance(expr, BindableTypes):
+            return None
         if not expr.literal:
             return
         self.invalidate_dependencies(expr)
@@ -202,16 +212,16 @@ def assign_type(self, expr: Expression,
                 and not restrict_any):
             pass
         elif isinstance(type, AnyType):
-            self.push(expr, declared_type)
+            self.put_if_bindable(expr, declared_type)
         else:
-            self.push(expr, type)
+            self.put_if_bindable(expr, type)
 
         for i in self.try_frames:
             # XXX This should probably not copy the entire frame, but
             # 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: BindableExpression) -> None:
         """Invalidate knowledge of types that include expr, but not expr itself.
 
         For example, when expr is foo.bar, invalidate foo.bar.baz.
@@ -222,7 +232,7 @@ 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: BindableExpression, type: Type) -> Type:
         if isinstance(type, AnyType):
             return self.get_declaration(expr)
         key = expr.literal_hash

diff --git a/mypy/checker.py b/mypy/checker.py
@@ -1079,10 +1079,10 @@ 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:
-                    self.binder.assign_type(lvalue,
-                                            rvalue_type,
-                                            lvalue_type,
-                                            False)
+                    self.binder.assign_type_if_bindable(lvalue,
+                                                        rvalue_type,
+                                                        lvalue_type,
+                                                        False)
             elif index_lvalue:
                 self.check_indexed_assignment(index_lvalue, rvalue, rvalue)
 
@@ -1535,14 +1535,14 @@ def visit_if_stmt(self, s: IfStmt) -> Type:
                     with self.binder.frame_context(2):
                         if if_map:
                             for var, type in if_map.items():
-                                self.binder.push(var, type)
+                                self.binder.put_if_bindable(var, type)
 
                         self.accept(b)
                     breaking_out = breaking_out and self.binder.last_pop_breaking_out
 
                     if else_map:
                         for var, type in else_map.items():
-                            self.binder.push(var, type)
+                            self.binder.put_if_bindable(var, type)
                 if else_map is None:
                     # The condition is always true => remaining elif/else blocks
                     # can never be reached.
@@ -1585,7 +1585,7 @@ def visit_assert_stmt(self, s: AssertStmt) -> Type:
 
         if true_map:
             for var, type in true_map.items():
-                self.binder.push(var, type)
+                self.binder.put_if_bindable(var, type)
 
     def visit_raise_stmt(self, s: RaiseStmt) -> Type:
         """Type check a raise statement."""
@@ -1800,10 +1800,10 @@ def flatten(t: Expression) -> List[Expression]:
             s.expr.accept(self)
             for elt in flatten(s.expr):
                 if isinstance(elt, NameExpr):
-                    self.binder.assign_type(elt,
-                                            DeletedType(source=elt.name),
-                                            self.binder.get_declaration(elt),
-                                            False)
+                    self.binder.assign_type_if_bindable(elt,
+                                                        DeletedType(source=elt.name),
+                                                        self.binder.get_declaration(elt),
+                                                        False)
             return None
 
     def visit_decorator(self, e: Decorator) -> Type:

diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -150,18 +150,13 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
         return result
 
     def analyze_var_ref(self, var: Var, context: Context) -> Type:
-        if not var.type:
+        if var.type:
+            return var.type
+        else:
             if not var.is_ready and self.chk.in_checked_function():
                 self.chk.handle_cannot_determine_type(var.name(), context)
             # Implicit 'Any' type.
             return AnyType()
-        else:
-            # Look up local type of variable with type (inferred or explicit).
-            val = self.chk.binder.get(var)
-            if val is None:
-                return var.type
-            else:
-                return val
 
     def visit_call_expr(self, e: CallExpr) -> Type:
         """Type check a call expression."""
@@ -1201,7 +1196,7 @@ def check_boolean_op(self, e: OpExpr, context: Context) -> Type:
         with self.chk.binder.frame_context():
             if right_map:
                 for var, type in right_map.items():
-                    self.chk.binder.push(var, type)
+                    self.chk.binder.put_if_bindable(var, type)
 
             right_type = self.accept(e.right, left_type)
 
@@ -1700,7 +1695,7 @@ def check_for_comp(self, e: Union[GeneratorExpr, DictionaryComprehension]) -> No
 
                 if true_map:
                     for var, type in true_map.items():
-                        self.chk.binder.push(var, type)
+                        self.chk.binder.put_if_bindable(var, type)
 
     def visit_conditional_expr(self, e: ConditionalExpr) -> Type:
         cond_type = self.accept(e.cond)
@@ -1739,7 +1734,7 @@ def analyze_cond_branch(self, map: Optional[Dict[Node, Type]],
         with self.chk.binder.frame_context():
             if map:
                 for var, type in map.items():
-                    self.chk.binder.push(var, type)
+                    self.chk.binder.put_if_bindable(var, type)
             return self.accept(node, context=context)
 
     def visit_backquote_expr(self, e: BackquoteExpr) -> Type: