use slice match more often

Signed-off-by: tabokie <xy.tao@outlook.com>

Author: tabokie

clippy_lints/src/checked_conversions.rs

@@ -270,10 +270,7 @@ fn get_types_from_cast<'a>(
  let limit_from: Option<(&Expr<'_>, &str)> = call_from_cast.or_else(|| {
  if_chain! {
  // `from_type::from, to_type::max_value()`
- if let ExprKind::Call(from_func, args) = &expr.kind;
- // `to_type::max_value()`
- if args.len() == 1;
- if let limit = &args[0];
+ if let ExprKind::Call(from_func, [limit]) = &expr.kind;
  // `from_type::from`
  if let ExprKind::Path(ref path) = &from_func.kind;
  if let Some(from_sym) = get_implementing_type(path, INTS, "from");

clippy_lints/src/create_dir.rs

@@ -34,7 +34,7 @@ declare_lint_pass!(CreateDir => [CREATE_DIR]);
 impl LateLintPass<'_> for CreateDir {
  fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  if_chain! {
- if let ExprKind::Call(func, args) = expr.kind;
+ if let ExprKind::Call(func, [arg, ..]) = expr.kind;
  if let ExprKind::Path(ref path) = func.kind;
  if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
  if match_def_path(cx, def_id, &paths::STD_FS_CREATE_DIR);
@@ -45,7 +45,7 @@ impl LateLintPass<'_> for CreateDir {
  expr.span,
  "calling `std::fs::create_dir` where there may be a better way",
  "consider calling `std::fs::create_dir_all` instead",
- format!("create_dir_all({})", snippet(cx, args[0].span, "..")),
+ format!("create_dir_all({})", snippet(cx, arg.span, "..")),
  Applicability::MaybeIncorrect,
  )
  }

clippy_lints/src/from_str_radix_10.rs

@@ -46,7 +46,7 @@ declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
  fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
  if_chain! {
- if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
+ if let ExprKind::Call(maybe_path, [src, radix]) = &exp.kind;
  if let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind;
 
  // check if the first part of the path is some integer primitive
@@ -60,20 +60,19 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
  if pathseg.ident.name.as_str() == "from_str_radix";
 
  // check if the second argument is a primitive `10`
- if arguments.len() == 2;
- if let ExprKind::Lit(lit) = &arguments[1].kind;
+ if let ExprKind::Lit(lit) = &radix.kind;
  if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
 
  then {
- let expr = if let ExprKind::AddrOf(_, _, expr) = &arguments[0].kind {
+ let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
  let ty = cx.typeck_results().expr_ty(expr);
  if is_ty_stringish(cx, ty) {
  expr
  } else {
- &arguments[0]
+ &src
  }
  } else {
- &arguments[0]
+ &src
  };
 
  let sugg = Sugg::hir_with_applicability(

clippy_lints/src/loops/manual_memcpy.rs

@@ -119,11 +119,9 @@ fn build_manual_memcpy_suggestion<'tcx>(
 
  let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
  if_chain! {
- if let ExprKind::MethodCall(method, len_args, _) = end.kind;
+ if let ExprKind::MethodCall(method, [recv], _) = end.kind;
  if method.ident.name == sym::len;
- if len_args.len() == 1;
- if let Some(arg) = len_args.get(0);
- if path_to_local(arg) == path_to_local(base);
+ if path_to_local(recv) == path_to_local(base);
  then {
  if sugg.to_string() == end_str {
  sugg::EMPTY.into()
@@ -343,10 +341,8 @@ fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Opti
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
  if_chain! {
- if let ExprKind::MethodCall(method, args, _) = expr.kind;
+ if let ExprKind::MethodCall(method, [arg], _) = expr.kind;
  if method.ident.name == sym::clone;
- if args.len() == 1;
- if let Some(arg) = args.get(0);
  then { arg } else { expr }
  }
 }

clippy_lints/src/loops/needless_range_loop.rs

@@ -188,10 +188,9 @@ pub(super) fn check<'tcx>(
 
 fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
  if_chain! {
- if let ExprKind::MethodCall(method, len_args, _) = expr.kind;
- if len_args.len() == 1;
+ if let ExprKind::MethodCall(method, [recv], _) = expr.kind;
  if method.ident.name == sym::len;
- if let ExprKind::Path(QPath::Resolved(_, path)) = len_args[0].kind;
+ if let ExprKind::Path(QPath::Resolved(_, path)) = recv.kind;
  if path.segments.len() == 1;
  if path.segments[0].ident.name == var;
  then {

clippy_lints/src/manual_ok_or.rs

@@ -47,17 +47,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualOkOr {
  }
 
  if_chain! {
- if let ExprKind::MethodCall(method_segment, args, _) = scrutinee.kind;
+ if let ExprKind::MethodCall(method_segment, [receiver, or_expr, map_expr], _) = scrutinee.kind;
  if method_segment.ident.name == sym!(map_or);
- if args.len() == 3;
- let method_receiver = &args[0];
- let ty = cx.typeck_results().expr_ty(method_receiver);
+ let ty = cx.typeck_results().expr_ty(receiver);
  if is_type_diagnostic_item(cx, ty, sym::Option);
- let or_expr = &args[1];
- if is_ok_wrapping(cx, &args[2]);
+ if is_ok_wrapping(cx, map_expr);
  if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
  if is_lang_ctor(cx, err_path, ResultErr);
- if let Some(method_receiver_snippet) = snippet_opt(cx, method_receiver.span);
+ if let Some(method_receiver_snippet) = snippet_opt(cx, receiver.span);
  if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
  if let Some(indent) = indent_of(cx, scrutinee.span);
  then {

clippy_lints/src/map_err_ignore.rs

@@ -113,18 +113,18 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
  }
 
  // check if this is a method call (e.g. x.foo())
- if let ExprKind::MethodCall(method, args, _) = e.kind {
+ if let ExprKind::MethodCall(method, [_, arg], _) = e.kind {
  // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
  // Enum::Variant[2]))
- if method.ident.as_str() == "map_err" && args.len() == 2 {
+ if method.ident.name == sym!(map_err) {
  // make sure the first argument is a closure, and grab the CaptureRef, BodyId, and fn_decl_span
  // fields
  if let ExprKind::Closure(&Closure {
  capture_clause,
  body,
  fn_decl_span,
  ..
- }) = args[1].kind
+ }) = arg.kind
  {
  // check if this is by Reference (meaning there's no move statement)
  if capture_clause == CaptureBy::Ref {

clippy_lints/src/matches/match_as_ref.rs

@@ -72,10 +72,10 @@ fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotat
  if is_lang_ctor(cx, qpath, LangItem::OptionSome);
  if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
  if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
- if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
+ if let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind;
  if let ExprKind::Path(ref some_path) = e.kind;
- if is_lang_ctor(cx, some_path, LangItem::OptionSome) && args.len() == 1;
- if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
+ if is_lang_ctor(cx, some_path, LangItem::OptionSome);
+ if let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind;
  if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
  then {
  return Some(rb)

clippy_lints/src/matches/try_err.rs

@@ -23,12 +23,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
  // val,
  // };
  if_chain! {
- if let ExprKind::Call(match_fun, try_args) = scrutinee.kind;
+ if let ExprKind::Call(match_fun, [try_arg, ..]) = scrutinee.kind;
  if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
  if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
- if let Some(try_arg) = try_args.get(0);
- if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
- if let Some(err_arg) = err_args.get(0);
+ if let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind;
  if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
  if is_lang_ctor(cx, err_fun_path, ResultErr);
  if let Some(return_ty) = find_return_type(cx, &expr.kind);

clippy_lints/src/mem_replace.rs

@@ -163,8 +163,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
  }
 
  if_chain! {
- if let ExprKind::Call(repl_func, repl_args) = src.kind;
- if repl_args.is_empty();
+ if let ExprKind::Call(repl_func, []) = src.kind;
  if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
  if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
  then {
@@ -246,11 +245,10 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
  fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  if_chain! {
  // Check that `expr` is a call to `mem::replace()`
- if let ExprKind::Call(func, func_args) = expr.kind;
+ if let ExprKind::Call(func, [dest, src]) = expr.kind;
  if let ExprKind::Path(ref func_qpath) = func.kind;
  if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
  if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
- if let [dest, src] = func_args;
  then {
  check_replace_option_with_none(cx, src, dest, expr.span);
  check_replace_with_uninit(cx, src, dest, expr.span);