suggest adding a where-clause when that can help

suggest adding a where-clause when there is an unmet trait-bound that
can be satisfied if some type can implement it.

Author: Ariel Ben-Yehuda

src/doc/book/closures.md

@@ -371,14 +371,13 @@ assert_eq!(6, answer);
 This gives us these long, related errors:
 
 ```text
-error: the trait `core::marker::Sized` is not implemented for the type
-`core::ops::Fn(i32) -> i32` [E0277]
+error: the predicate `core::ops::Fn(i32) -> i32 : core::marker::Sized` is not satisfied [E0277]
 fn factory() -> (Fn(i32) -> i32) {
                 ^~~~~~~~~~~~~~~~
 note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time
 fn factory() -> (Fn(i32) -> i32) {
                 ^~~~~~~~~~~~~~~~
-error: the trait `core::marker::Sized` is not implemented for the type `core::ops::Fn(i32) -> i32` [E0277]
+error: the predicate `core::ops::Fn(i32) -> i32 : core::marker::Sized` is not satisfied [E0277]
 let f = factory();
     ^
 note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time

src/doc/book/concurrency.md

@@ -231,8 +231,8 @@ fn main() {
 This won't work, however, and will give us the error:
 
 ```text
-13:9: 13:22 error: the trait `core::marker::Send` is not
-            implemented for the type `alloc::rc::Rc<collections::vec::Vec<i32>>`
+13:9: 13:22 error: the predicate `alloc::rc::Rc<collections::vec::Vec<i32>> : core::marker::Send`
+            is not satisfied
 ...
 13:9: 13:22 note: `alloc::rc::Rc<collections::vec::Vec<i32>>`
             cannot be sent between threads safely

src/doc/book/traits.md

@@ -154,7 +154,7 @@ print_area(5);
 We get a compile-time error:
 
 ```text
-error: the trait `HasArea` is not implemented for the type `_` [E0277]
+error: the predicate `_ : HasArea` is not satisfied [E0277]
 ```
 
 ## Trait bounds on generic structs
@@ -496,7 +496,7 @@ impl FooBar for Baz {
 If we forget to implement `Foo`, Rust will tell us:
 
 ```text
-error: the trait `main::Foo` is not implemented for the type `main::Baz` [E0277]
+error: the predicate `main::Baz : main::Foo` is not satisfied [E0277]
 ```
 
 # Deriving

src/doc/book/vectors.md

@@ -56,8 +56,8 @@ v[j];
 Indexing with a non-`usize` type gives an error that looks like this:
 
 ```text
-error: the trait `core::ops::Index<i32>` is not implemented for the type
-`collections::vec::Vec<_>` [E0277]
+error: the predicate `collections::vec::Vec<_> : core::ops::Index<i32>`
+is not satisfied [E0277]
 v[j];
 ^~~~
 note: the type `collections::vec::Vec<_>` cannot be indexed by `i32`

src/doc/nomicon/coercions.md

@@ -64,7 +64,7 @@ fn main() {
 ```
 
 ```text
-<anon>:10:5: 10:8 error: the trait `Trait` is not implemented for the type `&mut i32` [E0277]
+<anon>:10:5: 10:8 error: the predicate `&mut i32 : Trait` is not satisfied [E0277]
 <anon>:10     foo(t);
               ^~~
 ```

src/librustc/diagnostics.rs

@@ -1006,8 +1006,7 @@ fn some_func<T: Foo>(foo: T) {
 fn main() {
     // we now call the method with the i32 type, which doesn't implement
     // the Foo trait
-    some_func(5i32); // error: the trait `Foo` is not implemented for the
-                     //        type `i32`
+    some_func(5i32); // error: the predicate `i32 : Foo` is not satisfied
 }
 ```
 

src/librustc/traits/error_reporting.rs

@@ -13,10 +13,12 @@ use super::{
     FulfillmentErrorCode,
     MismatchedProjectionTypes,
     Obligation,
+    ObligationCause,
     ObligationCauseCode,
     OutputTypeParameterMismatch,
     TraitNotObjectSafe,
     PredicateObligation,
+    SelectionContext,
     SelectionError,
     ObjectSafetyViolation,
     MethodViolationCode,
@@ -26,8 +28,9 @@ use super::{
 use fmt_macros::{Parser, Piece, Position};
 use middle::def_id::DefId;
 use infer::InferCtxt;
-use ty::{self, ToPredicate, ToPolyTraitRef, TraitRef, Ty, TyCtxt, TypeFoldable};
+use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt};
 use ty::fast_reject;
+use ty::fold::{TypeFoldable, TypeFolder};
 use util::nodemap::{FnvHashMap, FnvHashSet};
 
 use std::cmp;
@@ -100,9 +103,10 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
     }
 }
 
-fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
-                                     trait_ref: &TraitRef<'tcx>,
-                                     span: Span) -> Option<String> {
+fn on_unimplemented_note<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
+                                   trait_ref: ty::PolyTraitRef<'tcx>,
+                                   span: Span) -> Option<String> {
+    let trait_ref = trait_ref.skip_binder();
     let def_id = trait_ref.def_id;
     let mut report = None;
     for item in infcx.tcx.get_attrs(def_id).iter() {
@@ -357,14 +361,20 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                             let trait_ref = trait_predicate.to_poly_trait_ref();
                             let mut err = struct_span_err!(
                                 infcx.tcx.sess, obligation.cause.span, E0277,
-                                "the trait `{}` is not implemented for the type `{}`",
-                                trait_ref, trait_ref.self_ty());
-
-                            // Check if it has a custom "#[rustc_on_unimplemented]"
-                            // error message, report with that message if it does
-                            let custom_note = report_on_unimplemented(infcx, &trait_ref.0,
-                                                                      obligation.cause.span);
-                            if let Some(s) = custom_note {
+                                "the predicate `{}` is not satisfied",
+                                trait_ref.to_predicate());
+
+                            // Try to report a good error message.
+
+                            if !trait_ref.has_infer_types() &&
+                                predicate_can_apply(infcx, trait_ref)
+                            {
+                                err.fileline_help(obligation.cause.span, &format!(
+                                    "consider adding a `where {}` bound",
+                                    trait_ref.to_predicate()
+                                    ));
+                            } else if let Some(s) = on_unimplemented_note(infcx, trait_ref,
+                                                                          obligation.cause.span) {
                                 err.fileline_note(obligation.cause.span, &s);
                             } else {
                                 let simp = fast_reject::simplify_type(infcx.tcx,
@@ -644,6 +654,55 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
     }
 }
 
+/// Returns whether the trait predicate may apply for *some* assignment
+/// to the type parameters.
+fn predicate_can_apply<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
+                                 pred: ty::PolyTraitRef<'tcx>)
+                                 -> bool
+{
+    struct ParamToVarFolder<'a, 'tcx: 'a> {
+        infcx: &'a InferCtxt<'a, 'tcx>,
+        var_map: FnvHashMap<Ty<'tcx>, Ty<'tcx>>
+    }
+
+    impl<'a, 'tcx> TypeFolder<'tcx> for ParamToVarFolder<'a, 'tcx>
+    {
+        fn tcx(&self) -> &TyCtxt<'tcx> { self.infcx.tcx }
+
+        fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+            if let ty::TyParam(..) = ty.sty {
+                let infcx = self.infcx;
+                self.var_map.entry(ty).or_insert_with(|| infcx.next_ty_var())
+            } else {
+                ty.super_fold_with(self)
+            }
+        }
+    }
+
+    infcx.probe(|_| {
+        let mut selcx = SelectionContext::new(infcx);
+
+        let cleaned_pred = pred.fold_with(&mut ParamToVarFolder {
+            infcx: infcx,
+            var_map: FnvHashMap()
+        });
+
+        let cleaned_pred = super::project::normalize(
+            &mut selcx,
+            ObligationCause::dummy(),
+            &cleaned_pred
+        ).value;
+
+        let obligation = Obligation::new(
+            ObligationCause::dummy(),
+            cleaned_pred.to_predicate()
+        );
+
+        selcx.evaluate_obligation(&obligation)
+    })
+}
+
+
 fn need_type_info<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                             span: Span,
                             ty: Ty<'tcx>)

src/test/compile-fail/associated-types-ICE-when-projecting-out-of-err.rs

@@ -31,5 +31,5 @@ trait Add<RHS=Self> {
 fn ice<A>(a: A) {
     let r = loop {};
     r = r + a;
-    //~^ ERROR not implemented
+    //~^ ERROR E0277
 }

src/test/compile-fail/associated-types-bound-failure.rs

@@ -24,7 +24,7 @@ pub trait GetToInt
 fn foo<G>(g: G) -> isize
     where G : GetToInt
 {
-    ToInt::to_int(&g.get()) //~ ERROR not implemented
+    ToInt::to_int(&g.get()) //~ ERROR E0277
 }
 
 fn bar<G : GetToInt>(g: G) -> isize

src/test/compile-fail/associated-types-for-unimpl-trait.rs

@@ -15,7 +15,7 @@ trait Get {
 
 trait Other {
     fn uhoh<U:Get>(&self, foo: U, bar: <Self as Get>::Value) {}
-    //~^ ERROR the trait `Get` is not implemented for the type `Self`
+    //~^ ERROR the predicate `Self : Get` is not satisfied
 }
 
 fn main() {