Remove unnecessary sigils around Ident::as_str() calls.

clippy_lints/src/duration_subsec.rs

@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
  if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::DURATION);
  if let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right);
  then {
- let suggested_fn = match (method_path.ident.as_str().as_ref(), divisor) {
+ let suggested_fn = match (method_path.ident.as_str(), divisor) {
  ("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
  ("subsec_nanos", 1_000) => "subsec_micros",
  _ => return,

clippy_lints/src/floating_point_arithmetic.rs

@@ -599,7 +599,7 @@ fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>
  return method_name_a.as_str() == method_name_b.as_str() &&
  args_a.len() == args_b.len() &&
  (
- ["ln", "log2", "log10"].contains(&&*method_name_a.as_str()) ||
+ ["ln", "log2", "log10"].contains(&method_name_a.as_str()) ||
  method_name_a.as_str() == "log" && args_a.len() == 2 && eq_expr_value(cx, &args_a[1], &args_b[1])
  );
  }

clippy_lints/src/loops/mod.rs

@@ -659,7 +659,7 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
  let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
 
  if let ExprKind::MethodCall(method, _, [self_arg], _) = arg.kind {
- let method_name = &*method.ident.as_str();
+ let method_name = method.ident.as_str();
  // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
  match method_name {
  "iter" | "iter_mut" => explicit_iter_loop::check(cx, self_arg, arg, method_name),

clippy_lints/src/match_str_case_mismatch.rs

@@ -95,7 +95,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MatchExprVisitor<'a, 'tcx> {
  fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
  match ex.kind {
  ExprKind::MethodCall(segment, _, [receiver], _)
- if self.case_altered(&*segment.ident.as_str(), receiver) => {},
+ if self.case_altered(segment.ident.as_str(), receiver) => {},
  _ => walk_expr(self, ex),
  }
  }

clippy_lints/src/matches.rs

@@ -1127,7 +1127,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
  if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
  let mut s = String::new();
  for seg in path_prefix {
- s.push_str(&seg.ident.as_str());
+ s.push_str(seg.ident.as_str());
  s.push_str("::");
  }
  s

clippy_lints/src/methods/manual_saturating_arithmetic.rs

@@ -81,7 +81,7 @@ fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<M
  if args.is_empty();
  if let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = &func.kind;
  then {
- match &*segment.ident.as_str() {
+ match segment.ident.as_str() {
  "max_value" => return Some(MinMax::Max),
  "min_value" => return Some(MinMax::Min),
  _ => {}

clippy_lints/src/methods/mod.rs

@@ -1999,8 +1999,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
  from_iter_instead_of_collect::check(cx, expr, args, func);
  },
  hir::ExprKind::MethodCall(method_call, ref method_span, args, _) => {
- or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
- expect_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
+ or_fun_call::check(cx, expr, *method_span, method_call.ident.as_str(), args);
+ expect_fun_call::check(cx, expr, *method_span, method_call.ident.as_str(), args);
  clone_on_copy::check(cx, expr, method_call.ident.name, args);
  clone_on_ref_ptr::check(cx, expr, method_call.ident.name, args);
  inefficient_to_string::check(cx, expr, method_call.ident.name, args);

clippy_lints/src/methods/str_splitn.rs

@@ -140,7 +140,7 @@ fn parse_iter_usage(
  let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
  let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
 
- match (&*name.ident.as_str(), args) {
+ match (name.ident.as_str(), args) {
  ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
  if reverse {
  (IterUsageKind::Second, e.span)
@@ -298,7 +298,7 @@ fn check_iter(
  if let Some(did) = cx.typeck_results().type_dependent_def_id(e.hir_id);
  if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
  then {
- match (&*name.ident.as_str(), args) {
+ match (name.ident.as_str(), args) {
  ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
  return true;
  },

clippy_lints/src/mut_reference.rs

@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
  let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
  let substs = cx.typeck_results().node_substs(e.hir_id);
  let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
- check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method");
+ check_arguments(cx, arguments, method_type, path.ident.as_str(), "method");
  },
  _ => (),
  }

clippy_lints/src/needless_option_as_deref.rs

@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for OptionNeedlessDeref {
  if is_type_diagnostic_item(cx,outer_ty,sym::Option);
  if let ExprKind::MethodCall(path, _, [sub_expr], _) = expr.kind;
  let symbol = path.ident.as_str();
- if symbol=="as_deref" || symbol=="as_deref_mut";
+ if symbol == "as_deref" || symbol == "as_deref_mut";
  if TyS::same_type( outer_ty, typeck.expr_ty(sub_expr) );
  then{
  span_lint_and_sugg(

clippy_lints/src/open_options.rs

@@ -82,7 +82,7 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
  _ => Argument::Unknown,
  };
 
- match &*path.ident.as_str() {
+ match path.ident.as_str() {
  "create" => {
  options.push((OpenOption::Create, argument_option));
  },

clippy_lints/src/serde_api.rs

@@ -37,7 +37,7 @@ impl<'tcx> LateLintPass<'tcx> for SerdeApi {
  let mut seen_str = None;
  let mut seen_string = None;
  for item in items {
- match &*item.ident.as_str() {
+ match item.ident.as_str() {
  "visit_str" => seen_str = Some(item.span),
  "visit_string" => seen_string = Some(item.span),
  _ => {},

clippy_lints/src/unused_io_amount.rs

@@ -57,7 +57,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
  check_map_error(cx, res, expr);
  }
  },
- hir::ExprKind::MethodCall(path, _, [ref arg_0, ..], _) => match &*path.ident.as_str() {
+ hir::ExprKind::MethodCall(path, _, [ref arg_0, ..], _) => match path.ident.as_str() {
  "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
  check_map_error(cx, arg_0, expr);
  },
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
 fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
  let mut call = call;
  while let hir::ExprKind::MethodCall(path, _, args, _) = call.kind {
- if matches!(&*path.ident.as_str(), "or" | "or_else" | "ok") {
+ if matches!(path.ident.as_str(), "or" | "or_else" | "ok") {
  call = &args[0];
  } else {
  break;
@@ -82,7 +82,7 @@ fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<
 
 fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
  if let hir::ExprKind::MethodCall(path, _, _, _) = call.kind {
- let symbol = &*path.ident.as_str();
+ let symbol = path.ident.as_str();
  let read_trait = match_trait_method(cx, call, &paths::IO_READ);
  let write_trait = match_trait_method(cx, call, &paths::IO_WRITE);
 

clippy_lints/src/unwrap.rs

@@ -158,7 +158,7 @@ fn collect_unwrap_info<'tcx>(
  if let Some(local_id) = path_to_local(&args[0]);
  let ty = cx.typeck_results().expr_ty(&args[0]);
  let name = method_name.ident.as_str();
- if is_relevant_option_call(cx, ty, &name) || is_relevant_result_call(cx, ty, &name);
+ if is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name);
  then {
  assert!(args.len() == 1);
  let unwrappable = match name.as_ref() {

clippy_lints/src/upper_case_acronyms.rs

@@ -79,7 +79,7 @@ fn correct_ident(ident: &str) -> String {
 
 fn check_ident(cx: &LateContext<'_>, ident: &Ident, be_aggressive: bool) {
  let span = ident.span;
- let ident = &ident.as_str();
+ let ident = ident.as_str();
  let corrected = correct_ident(ident);
  // warn if we have pure-uppercase idents
  // assume that two-letter words are some kind of valid abbreviation like FP for false positive

clippy_lints/src/useless_conversion.rs

@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
  },
 
  ExprKind::MethodCall(name, .., args, _) => {
- if is_trait_method(cx, e, sym::Into) && &*name.ident.as_str() == "into" {
+ if is_trait_method(cx, e, sym::Into) && name.ident.as_str() == "into" {
  let a = cx.typeck_results().expr_ty(e);
  let b = cx.typeck_results().expr_ty(&args[0]);
  if same_type_and_consts(a, b) {