Remove/assert casts (#2272)

elazarg · gvanrossum · commit 66c7148f4502 · 2016-10-28T12:49:49.000-07:00
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -1323,9 +1323,9 @@ def check_lvalue(self, lvalue: Lvalue) -> Tuple[Type, IndexExpr, Var]:
                 inferred = cast(Var, lvalue.node)
                 assert isinstance(inferred, Var)
             else:
-                m = cast(MemberExpr, lvalue)
-                self.accept(m.expr)
-                inferred = m.def_var
+                assert isinstance(lvalue, MemberExpr)
+                self.accept(lvalue.expr)
+                inferred = lvalue.def_var
         elif isinstance(lvalue, IndexExpr):
             index_lvalue = lvalue
         elif isinstance(lvalue, MemberExpr):
diff --git a/mypy/checkmember.py b/mypy/checkmember.py
@@ -273,7 +273,8 @@ def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Cont
                 if var.is_property:
                     # A property cannot have an overloaded type => the cast
                     # is fine.
-                    return cast(CallableType, signature).ret_type
+                    assert isinstance(signature, CallableType)
+                    return signature.ret_type
                 else:
                     return signature
         return t
@@ -485,8 +486,9 @@ def type_object_type_from_function(init_or_new: FuncBase, info: TypeInfo,
         return class_callable(signature, info, fallback, special_sig)
     else:
         # Overloaded __init__/__new__.
+        assert isinstance(signature, Overloaded)
         items = []  # type: List[CallableType]
-        for item in cast(Overloaded, signature).items():
+        for item in signature.items():
             items.append(class_callable(item, info, fallback, special_sig))
         return Overloaded(items)
 
diff --git a/mypy/checkstrformat.py b/mypy/checkstrformat.py
@@ -151,12 +151,11 @@ def check_simple_str_interpolation(self, specifiers: List[ConversionSpecifier],
 
     def check_mapping_str_interpolation(self, specifiers: List[ConversionSpecifier],
                                        replacements: Expression) -> None:
-        dict_with_only_str_literal_keys = (isinstance(replacements, DictExpr) and
-                                          all(isinstance(k, (StrExpr, BytesExpr))
-                                              for k, v in replacements.items))
-        if dict_with_only_str_literal_keys:
+        if (isinstance(replacements, DictExpr) and
+                all(isinstance(k, (StrExpr, BytesExpr))
+                    for k, v in replacements.items)):
             mapping = {}  # type: Dict[str, Type]
-            for k, v in cast(DictExpr, replacements).items:
+            for k, v in replacements.items:
                 key_str = cast(StrExpr, k).value
                 mapping[key_str] = self.accept(v)
 
diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -1,4 +1,4 @@
-from typing import Dict, List, cast
+from typing import Dict, List
 
 from mypy.types import (
     Type, Instance, CallableType, TypeVisitor, UnboundType, ErrorType, AnyType,
@@ -85,7 +85,9 @@ def visit_callable_type(self, t: CallableType) -> Type:
     def visit_overloaded(self, t: Overloaded) -> Type:
         items = []  # type: List[CallableType]
         for item in t.items():
-            items.append(cast(CallableType, item.accept(self)))
+            new_item = item.accept(self)
+            assert isinstance(new_item, CallableType)
+            items.append(new_item)
         return Overloaded(items)
 
     def visit_tuple_type(self, t: TupleType) -> Type:
diff --git a/mypy/join.py b/mypy/join.py
@@ -235,8 +235,9 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             for i in range(t.length()):
                 items.append(self.join(t.items[i], self.s.items[i]))
             # join fallback types if they are different
-            from typing import cast
-            return TupleType(items, cast(Instance, join_instances(self.s.fallback, t.fallback)))
+            fallback = join_instances(self.s.fallback, t.fallback)
+            assert isinstance(fallback, Instance)
+            return TupleType(items, fallback)
         else:
             return self.default(self.s)
 
diff --git a/mypy/maptype.py b/mypy/maptype.py
@@ -1,4 +1,4 @@
-from typing import Dict, List, cast
+from typing import Dict, List
 
 from mypy.expandtype import expand_type
 from mypy.nodes import TypeInfo
@@ -76,7 +76,9 @@ def map_instance_to_direct_supertypes(instance: Instance,
     for b in typ.bases:
         if b.type == supertype:
             env = instance_to_type_environment(instance)
-            result.append(cast(Instance, expand_type(b, env)))
+            t = expand_type(b, env)
+            assert isinstance(t, Instance)
+            result.append(t)
 
     if result:
         return result
diff --git a/mypy/parsetype.py b/mypy/parsetype.py
@@ -1,6 +1,6 @@
 """Type parser"""
 
-from typing import List, Tuple, Union, cast, Optional
+from typing import List, Tuple, Union, Optional
 
 from mypy.types import (
     Type, UnboundType, TupleType, TypeList, CallableType, StarType,
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -112,9 +112,9 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                     return self.builtin_type('builtins.tuple')
                 if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
                     # Tuple[T, ...] (uniform, variable-length tuple)
-                    node = self.lookup_fqn_func('builtins.tuple')
-                    tuple_info = cast(TypeInfo, node.node)
-                    return Instance(tuple_info, [t.args[0].accept(self)], t.line)
+                    instance = self.builtin_type('builtins.tuple', [t.args[0].accept(self)])
+                    instance.line = t.line
+                    return instance
                 return self.tuple_type(self.anal_array(t.args))
             elif fullname == 'typing.Union':
                 items = self.anal_array(t.args)
@@ -291,8 +291,8 @@ def anal_var_defs(self, var_defs: List[TypeVarDef]) -> List[TypeVarDef]:
 
     def builtin_type(self, fully_qualified_name: str, args: List[Type] = None) -> Instance:
         node = self.lookup_fqn_func(fully_qualified_name)
-        info = cast(TypeInfo, node.node)
-        return Instance(info, args or [])
+        assert isinstance(node.node, TypeInfo)
+        return Instance(node.node, args or [])
 
     def tuple_type(self, items: List[Type]) -> TupleType:
         return TupleType(items, fallback=self.builtin_type('builtins.tuple', [AnyType()]))
