Declare literal_hash as Optional[Key]

mypy/binder.py

@@ -122,6 +122,7 @@ def put(self, expr: Expression, typ: Type) -> None:
         if not expr.literal:
             return
         key = expr.literal_hash
+        assert key is not None, 'Internal error: binder tried to put non-literal'
         if key not in self.declarations:
             assert isinstance(expr, BindableTypes)
             self.declarations[key] = get_declaration(expr)
@@ -132,6 +133,7 @@ def unreachable(self) -> None:
         self.frames[-1].unreachable = True
 
     def get(self, expr: Expression) -> Optional[Type]:
+        assert expr.literal_hash is not None, 'Internal error: binder tried to get non-literal'
         return self._get(expr.literal_hash)
 
     def is_unreachable(self) -> bool:
@@ -141,6 +143,7 @@ def is_unreachable(self) -> bool:
 
     def cleanse(self, expr: Expression) -> None:
         """Remove all references to a Node from the binder."""
+        assert expr.literal_hash is not None, 'Internal error: binder tried cleanse non-literal'
         self._cleanse_key(expr.literal_hash)
 
     def _cleanse_key(self, key: Key) -> None:
@@ -258,13 +261,15 @@ def invalidate_dependencies(self, expr: BindableExpression) -> None:
         It is overly conservative: it invalidates globally, including
         in code paths unreachable from here.
         """
+        assert expr.literal_hash is not None
         for dep in self.dependencies.get(expr.literal_hash, set()):
             self._cleanse_key(dep)
 
     def most_recent_enclosing_type(self, expr: BindableExpression, type: Type) -> Optional[Type]:
         if isinstance(type, AnyType):
             return get_declaration(expr)
         key = expr.literal_hash
+        assert key is not None
         enclosers = ([get_declaration(expr)] +
                      [f[key] for f in self.frames
                       if key in f and is_subtype(type, f[key])])

mypy/nodes.py

@@ -156,7 +156,7 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 class Expression(Node):
     """An expression node."""
     literal = LITERAL_NO
-    literal_hash = None  # type: Key
+    literal_hash = None  # type: Optional[Key]
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         raise RuntimeError('Not implemented')