simplify suggest_deref_ref_or_into

compiler/rustc_hir/src/hir.rs

@@ -1811,6 +1811,14 @@ impl Expr<'_> {
             _ => false,
         }
     }
+
+    pub fn method_ident(&self) -> Option<Ident> {
+        match self.kind {
+            ExprKind::MethodCall(receiver_method, ..) => Some(receiver_method.ident),
+            ExprKind::Unary(_, expr) | ExprKind::AddrOf(.., expr) => expr.method_ident(),
+            _ => None,
+        }
+    }
 }
 
 /// Checks if the specified expression is a built-in range literal.

compiler/rustc_span/src/symbol.rs

@@ -1434,6 +1434,8 @@ symbols! {
         thumb2,
         thumb_mode: "thumb-mode",
         tmm_reg,
+        to_string,
+        to_vec,
         todo_macro,
         tool_attributes,
         tool_lints,

compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs

@@ -14,12 +14,10 @@ use rustc_infer::infer::{self, TyCtxtInferExt};
 use rustc_infer::traits;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Binder, IsSuggestable, Subst, ToPredicate, Ty};
-use rustc_span::symbol::{sym, Ident};
+use rustc_span::symbol::sym;
 use rustc_span::Span;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 
-use std::iter;
-
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(in super::super) fn suggest_semicolon_at_end(&self, span: Span, err: &mut Diagnostic) {
         err.span_suggestion_short(
@@ -187,46 +185,41 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 err.span_label(self.tcx.def_span(def_id), &format!("{} defined here", found));
             }
         } else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
-            let struct_pat_shorthand_field = self.maybe_get_struct_pattern_shorthand_field(expr);
             let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
             if !methods.is_empty() {
-                let mut suggestions = iter::zip(iter::repeat(&expr), &methods)
+                let mut suggestions = methods.iter()
-                    .filter_map(|(receiver_expr, method)| {
+                    .filter_map(|conversion_method| {
-                        let method_call = format!(".{}()", method.name);
+                        let receiver_method_ident = expr.method_ident();
-                        fn method_ident(expr: &hir::Expr<'_>) -> Option<Ident> {
+                        if let Some(method_ident) = receiver_method_ident
-                            match expr.kind {
+                            && method_ident.name == conversion_method.name
-                                ExprKind::MethodCall(receiver_method, ..) => Some(receiver_method.ident),
-                                ExprKind::Unary(_, expr) | ExprKind::AddrOf(.., expr) => method_ident(expr),
-                                _ => None
-                            }
-                        }
-                        let method_ident = method_ident(&receiver_expr);
-                        if let Some(method_ident) = method_ident
-                            && method_ident.name == method.name
                         {
-                            None // do not suggest code that is already there (#53348)
+                            return None // do not suggest code that is already there (#53348)
-                        } else {
+                        }
-                            let method_call_list = [".to_vec()", ".to_string()"];
+
-                            let mut sugg = if let ExprKind::MethodCall(receiver_method, ..) = receiver_expr.kind
+                        let method_call_list = [sym::to_vec, sym::to_string];
+                        let mut sugg = if let ExprKind::MethodCall(receiver_method, ..) = expr.kind
                             && receiver_method.ident.name == sym::clone
-                                && method_call_list.contains(&method_call.as_str())
+                            && method_call_list.contains(&conversion_method.name)
+                            // If receiver is `.clone()` and found type has one of those methods,
+                            // we guess that the user wants to convert from a slice type (`&[]` or `&str`)
+                            // to an owned type (`Vec` or `String`).  These conversions clone internally,
+                            // so we remove the user's `clone` call.
                         {
                             vec![(
                                 receiver_method.ident.span,
-                                    method.name.to_string()
+                                conversion_method.name.to_string()
                             )]
-                            } else {
+                        } else if expr.precedence().order()
-                                if expr.precedence().order()
                             < ExprPrecedence::MethodCall.order()
                         {
                             vec![
                                 (expr.span.shrink_to_lo(), "(".to_string()),
-                                        (expr.span.shrink_to_hi(), format!("){}", method_call)),
+                                (expr.span.shrink_to_hi(), format!(").{}()", conversion_method.name)),
                             ]
                         } else {
-                                    vec![(expr.span.shrink_to_hi(), method_call)]
+                            vec![(expr.span.shrink_to_hi(), format!(".{}()", conversion_method.name))]
-                                }
                         };
+                        let struct_pat_shorthand_field = self.maybe_get_struct_pattern_shorthand_field(expr);
                         if let Some(name) = struct_pat_shorthand_field {
                             sugg.insert(
                                 0,
@@ -234,7 +227,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             );
                         }
                         Some(sugg)
-                        }
                     })
                     .peekable();
                 if suggestions.peek().is_some() {