Implement clone suggestion on move errors

This is continuation on the "copy suggestions". The logic is as follows:
- If the type is already `Clone` - clone it
- If it can be `Copy` - make it copy
- If it can be `Clone` - make it clone and the clone it
- Otherwise feel sad

Note that clone suggestions may be incorrect in many cases, like for
example `S{t}; t` that suggests `S{t.clone()}; t`.
See `use_of_moved_value_clone_suggestions_bad.rs` for more problematic
cases.

Author: WaffleLapkin

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -175,12 +175,15 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             let mut is_loop_move = false;
             let mut in_pattern = false;
 
+            let mut to_clone_spans = Vec::new();
+
             for move_site in &move_site_vec {
                 let move_out = self.move_data.moves[(*move_site).moi];
                 let moved_place = &self.move_data.move_paths[move_out.path].place;
 
                 let move_spans = self.move_spans(moved_place.as_ref(), move_out.source);
                 let move_span = move_spans.args_or_use();
+                to_clone_spans.push(move_spans.var_or_use_path_span());
 
                 let move_msg = if move_spans.for_closure() { " into closure" } else { "" };
 
@@ -293,18 +296,62 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                     .and_then(|def_id| tcx.hir().get_generics(def_id))
                 {
                     let copy_did = tcx.lang_items().copy_trait().unwrap();
-                    let predicates =
+                    let copy_predicates =
                         self.try_find_missing_generic_bounds(ty, copy_did, generics, span);
 
-                    if let Ok(predicates) = predicates {
-                        suggest_constraining_type_params(
-                            tcx,
-                            hir_generics,
-                            &mut err,
-                            predicates.iter().map(|(param, constraint)| {
-                                (param.name.as_str(), &**constraint, None)
-                            }),
-                        );
+                    let clone_did = tcx.lang_items().clone_trait().unwrap();
+                    let clone_predicates =
+                        self.try_find_missing_generic_bounds(ty, clone_did, generics, span);
+
+                    match (copy_predicates, clone_predicates) {
+                        // The type is already `Clone`, suggest cloning all values
+                        (_, Ok(clone_predicates)) if clone_predicates.is_empty() => {
+                            err.multipart_suggestion_verbose(
+                                &format!("consider cloning {}", note_msg),
+                                to_clone_spans
+                                    .into_iter()
+                                    .map(|move_span| {
+                                        (move_span.shrink_to_hi(), ".clone()".to_owned())
+                                    })
+                                    .collect(),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                        // The type can *not* be `Copy`, but can be `Clone`, suggest adding bounds to make the type `Clone` and then cloning all values
+                        (Err(_), Ok(clone_predicates)) => {
+                            suggest_constraining_type_params(
+                                tcx,
+                                hir_generics,
+                                &mut err,
+                                clone_predicates.iter().map(|(param, constraint)| {
+                                    (param.name.as_str(), &**constraint, None)
+                                }),
+                            );
+
+                            err.multipart_suggestion_verbose(
+                                &format!("...and cloning {}", note_msg),
+                                to_clone_spans
+                                    .into_iter()
+                                    .map(|move_span| {
+                                        (move_span.shrink_to_hi(), ".clone()".to_owned())
+                                    })
+                                    .collect(),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                        // The type can be `Copy`, suggest adding bound to make it `Copy`
+                        (Ok(copy_predicates), _) => {
+                            suggest_constraining_type_params(
+                                tcx,
+                                hir_generics,
+                                &mut err,
+                                copy_predicates.iter().map(|(param, constraint)| {
+                                    (param.name.as_str(), &**constraint, None)
+                                }),
+                            );
+                        }
+                        // The type can never be `Clone` or `Copy`, there is nothing to suggest :(
+                        (Err(_), Err(_)) => {}
                     }
                 }
 

src/test/ui/moves/use_of_moved_value_clone_suggestions.rs

@@ -1,6 +1,32 @@
-// `Rc` is not ever `Copy`, we should not suggest adding `T: Copy` constraint
-fn duplicate_rc<T>(t: std::rc::Rc<T>) -> (std::rc::Rc<T>, std::rc::Rc<T>) {
-    (t, t) //~ use of moved value: `t`
+// run-rustfix
+#![allow(dead_code)]
+
+// `Rc` is not ever `Copy`, we should not suggest adding `T: Copy` constraint.
+// But should suggest adding `.clone()`.
+fn move_rc<T>(t: std::rc::Rc<T>) {
+    [t, t]; //~ use of moved value: `t`
+}
+
+// Even though `T` could be `Copy` it's already `Clone` so don't suggest adding `T: Copy` constraint,
+// instead suggest adding `.clone()`.
+fn move_clone_already<T: Clone>(t: T) {
+    [t, t]; //~ use of moved value: `t`
+}
+
+// Same as `Rc`
+fn move_clone_only<T>(t: (T, String)) {
+    [t, t]; //~ use of moved value: `t`
+}
+
+// loop
+fn move_in_a_loop<T: Clone>(t: T) {
+    loop {
+        if true {
+            drop(t); //~ use of moved value: `t`
+        } else {
+            drop(t);
+        }
+    }
 }
 
 fn main() {}

src/test/ui/moves/use_of_moved_value_clone_suggestions_bad.rs

@@ -0,0 +1,27 @@
+// Bad `.clone()` suggestions
+
+struct S<A> {
+    t: A,
+}
+
+fn struct_field_shortcut_move<T: Clone>(t: T) {
+    S { t };
+    t; //~ use of moved value: `t`
+}
+
+fn closure_clone_will_not_help<T: Clone>(t: T) {
+    (move || {
+        t;
+    })();
+    t; //~ use of moved value: `t`
+}
+
+#[derive(Clone)]
+struct CloneOnly;
+
+fn update_syntax<T: Clone>(s: S<T>) {
+    S { ..s };
+    S { ..s }; //~ use of moved value: `s.t`
+}
+
+fn main() {}

src/test/ui/moves/use_of_moved_value_no_suggestions.rs

@@ -0,0 +1,9 @@
+// No suggestions? :(
+
+// In the future, we may want to suggest deriving `Clone, Copy` for `No` (and then adding `T: Copy`)
+struct No;
+fn move_non_clone_non_copy<T>(t: (T, No)) {
+    [t, t]; //~ use of moved value: `t`
+}
+
+fn main() {}