Remove more redundant casts

mypy/checkmember.py

@@ -51,7 +51,6 @@ def analyze_member_access(name: str, typ: Type, node: Context, is_lvalue: bool,
  if method:
  if method.is_property:
  assert isinstance(method, OverloadedFuncDef)
- method = cast(OverloadedFuncDef, method)
  return analyze_var(name, method.items[0].var, typ, info, node, is_lvalue, msg,
  not_ready_callback)
  if is_lvalue:
@@ -204,7 +203,7 @@ def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Cont
  # Class-level function objects and classmethods become bound
  # methods: the former to the instance, the latter to the
  # class.
- functype = cast(FunctionLike, t)
+ functype = t
  check_method_type(functype, itype, var.is_classmethod, node, msg)
  signature = method_type(functype)
  if var.is_property:

mypy/checkstrformat.py

@@ -137,7 +137,7 @@ def check_mapping_str_interpolation(self, specifiers: List[ConversionSpecifier],
  replacements: Node) -> None:
  dict_with_only_str_literal_keys = (isinstance(replacements, DictExpr) and
  all(isinstance(k, (StrExpr, BytesExpr))
- for k, v in cast(DictExpr, replacements).items))
+ for k, v in replacements.items))
  if dict_with_only_str_literal_keys:
  mapping = {} # type: Dict[str, Type]
  for k, v in cast(DictExpr, replacements).items:

mypy/expandtype.py

@@ -70,7 +70,7 @@ def visit_instance(self, t: Instance) -> Type:
  def visit_type_var(self, t: TypeVarType) -> Type:
  repl = self.variables.get(t.id, t)
  if isinstance(repl, Instance):
- inst = cast(Instance, repl)
+ inst = repl
  # Return copy of instance with type erasure flag on.
  return Instance(inst.type, inst.args, inst.line, True)
  else:

mypy/fixup.py

@@ -250,7 +250,7 @@ def lookup_qualified_stnode(modules: Dict[str, MypyFile], name: str) -> SymbolTa
  return stnode
  node = stnode.node
  assert isinstance(node, TypeInfo)
- names = cast(TypeInfo, node).names
+ names = node.names
 
 
 def store_qualified(modules: Dict[str, MypyFile], name: str, info: SymbolNode) -> None:
@@ -278,4 +278,4 @@ def store_qualified(modules: Dict[str, MypyFile], name: str, info: SymbolNode) -
  stnode.node = info
  return
  assert isinstance(node, TypeInfo)
- names = cast(TypeInfo, node).names
+ names = node.names

mypy/nodes.py

@@ -2138,7 +2138,7 @@ def deserialize(cls, data: JsonDict) -> 'SymbolTable':
 def function_type(func: FuncBase, fallback: 'mypy.types.Instance') -> 'mypy.types.FunctionLike':
  if func.type:
  assert isinstance(func.type, mypy.types.FunctionLike)
- return cast(mypy.types.FunctionLike, func.type)
+ return func.type
  else:
  # Implicit type signature with dynamic types.
  # Overloaded functions always have a signature, so func must be an ordinary function.

mypy/parse.py

@@ -867,7 +867,7 @@ def parse_block(self, allow_type: bool = False) -> Tuple[Block, Type]:
  if allow_type:
  cur = self.current()
  if type is None and isinstance(cur, StrLit):
- ds = docstring.parse_docstring(cast(StrLit, cur).parsed())
+ ds = docstring.parse_docstring(cur.parsed())
  if ds and False: # TODO: Enable when this is working.
  try:
  type = parse_str_as_signature(ds.as_type_str(), cur.line)
@@ -894,15 +894,13 @@ def parse_block(self, allow_type: bool = False) -> Tuple[Block, Type]:
 
  def try_combine_overloads(self, s: Node, stmt: List[Node]) -> bool:
  if isinstance(s, Decorator) and stmt:
- fdef = cast(Decorator, s)
+ fdef = s
  n = fdef.func.name()
- if (isinstance(stmt[-1], Decorator) and
- (cast(Decorator, stmt[-1])).func.name() == n):
- stmt[-1] = OverloadedFuncDef([cast(Decorator, stmt[-1]), fdef])
+ if isinstance(stmt[-1], Decorator) and stmt[-1].func.name() == n:
+ stmt[-1] = OverloadedFuncDef([stmt[-1], fdef])
  return True
- elif (isinstance(stmt[-1], OverloadedFuncDef) and
- (cast(OverloadedFuncDef, stmt[-1])).name() == n):
- (cast(OverloadedFuncDef, stmt[-1])).items.append(fdef)
+ elif isinstance(stmt[-1], OverloadedFuncDef) and stmt[-1].name() == n:
+ stmt[-1].items.append(fdef)
  return True
  return False
 
@@ -1450,7 +1448,7 @@ def parse_list_expr(self) -> Node:
  items[0] = self.parse_generator_expr(items[0])
  self.expect(']')
  if len(items) == 1 and isinstance(items[0], GeneratorExpr):
- return ListComprehension(cast(GeneratorExpr, items[0]))
+ return ListComprehension(items[0])
  else:
  expr = ListExpr(items)
  return expr
@@ -1698,7 +1696,7 @@ def parse_member_expr(self, expr: Any) -> Node:
  self.expect('.')
  name = self.expect_type(Name)
  if (isinstance(expr, CallExpr) and isinstance(expr.callee, NameExpr)
- and cast(NameExpr, expr.callee).name == 'super'):
+ and expr.callee.name == 'super'):
  # super() expression
  node = SuperExpr(name.string) # type: Node
  else:

mypy/semanal.py

@@ -302,7 +302,7 @@ def visit_func_def(self, defn: FuncDef) -> None:
  original_def = symbol.node
  if self.is_conditional_func(original_def, defn):
  # Conditional function definition -- multiple defs are ok.
- defn.original_def = cast(FuncDef, original_def)
+ defn.original_def = original_def
  else:
  # Report error.
  self.check_no_global(defn.name(), defn, True)
@@ -695,7 +695,7 @@ def clean_up_bases_and_infer_type_variables(self, defn: ClassDef) -> None:
  def analyze_typevar_declaration(self, t: Type) -> Optional[List[Tuple[str, TypeVarExpr]]]:
  if not isinstance(t, UnboundType):
  return None
- unbound = cast(UnboundType, t)
+ unbound = t
  sym = self.lookup_qualified(unbound.name, unbound)
  if sym is None or sym.node is None:
  return None
@@ -714,7 +714,7 @@ def analyze_typevar_declaration(self, t: Type) -> Optional[List[Tuple[str, TypeV
  def analyze_unbound_tvar(self, t: Type) -> Tuple[str, TypeVarExpr]:
  if not isinstance(t, UnboundType):
  return None
- unbound = cast(UnboundType, t)
+ unbound = t
  sym = self.lookup_qualified(unbound.name, unbound)
  if sym is not None and sym.kind == UNBOUND_TVAR:
  return unbound.name, cast(TypeVarExpr, sym.node)
@@ -1054,7 +1054,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
  self.fail)
  if res and (not isinstance(res, Instance) or cast(Instance, res).args):
  # TODO: What if this gets reassigned?
- name = cast(NameExpr, s.lvalues[0])
+ name = s.lvalues[0]
  node = self.lookup(name.name, name)
  node.kind = TYPE_ALIAS
  node.type_override = res
@@ -1212,8 +1212,8 @@ def is_self_member_ref(self, memberexpr: MemberExpr) -> bool:
  """Does memberexpr to refer to an attribute of self?"""
  if not isinstance(memberexpr.expr, NameExpr):
  return False
- node = (cast(NameExpr, memberexpr.expr)).node
- return isinstance(node, Var) and (cast(Var, node)).is_self
+ node = memberexpr.expr.node
+ return isinstance(node, Var) and node.is_self
 
  def check_lvalue_validity(self, node: Node, ctx: Context) -> None:
  if isinstance(node, (TypeInfo, TypeVarExpr)):
@@ -1307,10 +1307,10 @@ def get_typevar_declaration(self, s: AssignmentStmt) -> Optional[CallExpr]:
  return None
  if not isinstance(s.rvalue, CallExpr):
  return None
- call = cast(CallExpr, s.rvalue)
+ call = s.rvalue
  if not isinstance(call.callee, RefExpr):
  return None
- callee = cast(RefExpr, call.callee)
+ callee = call.callee
  if callee.fullname != 'typing.TypeVar':
  return None
  return call
@@ -1405,10 +1405,10 @@ def check_namedtuple(self, node: Node, var_name: str = None) -> TypeInfo:
  """
  if not isinstance(node, CallExpr):
  return None
- call = cast(CallExpr, node)
+ call = node
  if not isinstance(call.callee, RefExpr):
  return None
- callee = cast(RefExpr, call.callee)
+ callee = call.callee
  fullname = callee.fullname
  if fullname not in ('collections.namedtuple', 'typing.NamedTuple'):
  return None
@@ -2588,7 +2588,7 @@ def builtin_type(self, name: str, args: List[Type] = None) -> Instance:
  names = self.modules['builtins']
  sym = names.names[name]
  assert isinstance(sym.node, TypeInfo)
- return Instance(cast(TypeInfo, sym.node), args or [])
+ return Instance(sym.node, args or [])
 
 
 def self_type(typ: TypeInfo) -> Union[Instance, TupleType]:

mypy/stats.py

@@ -88,8 +88,7 @@ def visit_type_application(self, o: TypeApplication) -> None:
  def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
  self.line = o.line
  if (isinstance(o.rvalue, nodes.CallExpr) and
- isinstance(cast(nodes.CallExpr, o.rvalue).analyzed,
- nodes.TypeVarExpr)):
+ isinstance(o.rvalue.analyzed, nodes.TypeVarExpr)):
  # Type variable definition -- not a real assignment.
  return
  if o.type:
@@ -256,7 +255,7 @@ def visit_callable_type(self, t: CallableType) -> bool:
 
 
 def is_generic(t: Type) -> bool:
- return isinstance(t, Instance) and bool(cast(Instance, t).args)
+ return isinstance(t, Instance) and bool(t.args)
 
 
 def is_complex(t: Type) -> bool:

mypy/subtypes.py

@@ -46,7 +46,7 @@ def is_subtype(left: Type, right: Type,
  return True
  elif isinstance(right, UnionType) and not isinstance(left, UnionType):
  return any(is_subtype(left, item, type_parameter_checker)
- for item in cast(UnionType, right).items)
+ for item in right.items)
  else:
  return left.accept(SubtypeVisitor(right, type_parameter_checker))
 

mypy/typeanal.py

@@ -110,8 +110,8 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
  if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
  # Tuple[T, ...] (uniform, variable-length tuple)
  node = self.lookup_fqn_func('builtins.tuple')
- info = cast(TypeInfo, node.node)
- return Instance(info, [t.args[0].accept(self)], t.line)
+ tuple_info = cast(TypeInfo, node.node)
+ return Instance(tuple_info, [t.args[0].accept(self)], t.line)
  return self.tuple_type(self.anal_array(t.args))
  elif fullname == 'typing.Union':
  items = self.anal_array(t.args)
@@ -152,7 +152,7 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
  return AnyType()
  self.fail('Invalid type "{}"'.format(name), t)
  return t
- info = cast(TypeInfo, sym.node)
+ info = sym.node # type: TypeInfo
  if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
  return TupleType(self.anal_array(t.args),
  Instance(info, [AnyType()], t.line),