Kill the remaining redundant casts. (#1827)

Ran `mypy --warn-redundant-casts mypy`.

Author: gvanrossum

mypy/checker.py

@@ -917,9 +917,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> Type:
     def check_assignment(self, lvalue: Node, rvalue: Node, infer_lvalue_type: bool = True) -> None:
         """Type check a single assignment: lvalue = rvalue."""
         if isinstance(lvalue, TupleExpr) or isinstance(lvalue, ListExpr):
-            ltuple = cast(Union[TupleExpr, ListExpr], lvalue)
-
-            self.check_assignment_to_multiple_lvalues(ltuple.items, rvalue, lvalue,
+            self.check_assignment_to_multiple_lvalues(lvalue.items, rvalue, lvalue,
                                                       infer_lvalue_type)
         else:
             lvalue_type, index_lvalue, inferred = self.check_lvalue(lvalue)
@@ -978,7 +976,7 @@ def check_assignment_to_multiple_lvalues(self, lvalues: List[Node], rvalue: Node
             # control in cases like: a, b = [int, str] where rhs would get
             # type List[object]
 
-            rvalues = cast(Union[TupleExpr, ListExpr], rvalue).items
+            rvalues = rvalue.items
 
             if self.check_rvalue_count_in_assignment(lvalues, len(rvalues), context):
                 star_index = next((i for i, lv in enumerate(lvalues) if
@@ -1164,8 +1162,7 @@ def check_lvalue(self, lvalue: Node) -> Tuple[Type, IndexExpr, Var]:
             lvalue_type = self.expr_checker.analyze_ref_expr(lvalue, lvalue=True)
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, TupleExpr) or isinstance(lvalue, ListExpr):
-            lv = cast(Union[TupleExpr, ListExpr], lvalue)
-            types = [self.check_lvalue(sub_expr)[0] for sub_expr in lv.items]
+            types = [self.check_lvalue(sub_expr)[0] for sub_expr in lvalue.items]
             lvalue_type = TupleType(types, self.named_type('builtins.tuple'))
         else:
             lvalue_type = self.accept(lvalue)
@@ -1663,7 +1660,6 @@ def visit_del_stmt(self, s: DelStmt) -> Type:
             def flatten(t: Node) -> List[Node]:
                 """Flatten a nested sequence of tuples/lists into one list of nodes."""
                 if isinstance(t, TupleExpr) or isinstance(t, ListExpr):
-                    t = cast(Union[TupleExpr, ListExpr], t)
                     return [b for a in t.items for b in flatten(a)]
                 else:
                     return [t]

mypy/checkexpr.py

@@ -411,7 +411,7 @@ def infer_function_type_arguments_using_context(
         ret_type = callable.ret_type
         if isinstance(ret_type, TypeVarType):
             if ret_type.values or (not isinstance(ctx, Instance) or
-                                   not cast(Instance, ctx).args):
+                                   not ctx.args):
                 # The return type is a type variable. If it has values, we can't easily restrict
                 # type inference to conform to the valid values. If it's unrestricted, we could
                 # infer a too general type for the type variable if we use context, and this could

mypy/semanal.py

@@ -1058,7 +1058,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
                                          self.lookup_qualified,
                                          self.lookup_fully_qualified,
                                          self.fail)
-                if res and (not isinstance(res, Instance) or cast(Instance, res).args):
+                if res and (not isinstance(res, Instance) or res.args):
                     # TODO: What if this gets reassigned?
                     name = s.lvalues[0]
                     node = self.lookup(name.name, name)
@@ -1410,7 +1410,7 @@ def process_namedtuple_definition(self, s: AssignmentStmt) -> None:
         """Check if s defines a namedtuple; if yes, store the definition in symbol table."""
         if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
             return
-        lvalue = cast(NameExpr, s.lvalues[0])
+        lvalue = s.lvalues[0]
         name = lvalue.name
         named_tuple = self.check_namedtuple(s.rvalue, name)
         if named_tuple is None:

mypy/subtypes.py

@@ -338,7 +338,7 @@ def unify_generic_callable(type: CallableType, target: CallableType,
     applied = mypy.applytype.apply_generic_arguments(type, inferred_vars, msg, context=target)
     if msg.is_errors() or not isinstance(applied, CallableType):
         return None
-    return cast(CallableType, applied)
+    return applied
 
 
 def restrict_subtype_away(t: Type, s: Type) -> Type: