Handle projection obligation errors

Author: estebank

src/librustc/ty/wf.rs

@@ -164,37 +164,60 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
 
     /// Pushes the obligations required for `trait_ref` to be WF into `self.out`.
     fn compute_trait_ref(&mut self, trait_ref: &ty::TraitRef<'tcx>, elaborate: Elaborate) {
+        let tcx = self.infcx.tcx;
         let obligations = self.nominal_obligations(trait_ref.def_id, trait_ref.substs);
-        let assoc_items = self.infcx.tcx.associated_items(trait_ref.def_id);
+
         let cause = self.cause(traits::MiscObligation);
         let param_env = self.param_env;
 
         if let Elaborate::All = elaborate {
+            let trait_assoc_items = tcx.associated_items(trait_ref.def_id);
+
             let predicates = obligations.iter()
                 .map(|obligation| obligation.predicate.clone())
                 .collect();
-            let implied_obligations = traits::elaborate_predicates(self.infcx.tcx, predicates);
+            let implied_obligations = traits::elaborate_predicates(tcx, predicates);
             let item_span: Option<Span> = self.item.map(|i| i.span);
             let item = &self.item;
             let implied_obligations = implied_obligations.map(|pred| {
                 let mut cause = cause.clone();
-                if let ty::Predicate::Trait(proj) = &pred {
+                match &pred {
+                    ty::Predicate::Projection(proj) => {
+                        if let Some(hir::ItemKind::Impl(.., impl_items)) = item.map(|i| &i.kind) {
+                            let trait_assoc_item = tcx.associated_item(proj.projection_def_id());
+                            if let Some(impl_item) = impl_items.iter().filter(|item| {
+                                item.ident == trait_assoc_item.ident
+                            }).next() {
+                                cause.span = impl_item.span;
+                                cause.code = traits::AssocTypeBound(
+                                    item_span,
+                                    trait_assoc_item.ident.span,
+                                );
+                            }
+                        }
+                    }
+                    ty::Predicate::Trait(proj) => {
                     if let (
                         ty::Projection(ty::ProjectionTy { item_def_id, .. }),
-                        Some(hir::ItemKind::Impl(.., bounds)),
+                            Some(hir::ItemKind::Impl(.., impl_items)),
                      ) = (&proj.skip_binder().self_ty().kind, item.map(|i| &i.kind)) {
-                        if let Some((bound, assoc_item)) = assoc_items.clone()
+                            if let Some((impl_item, trait_assoc_item)) = trait_assoc_items.clone()
                             .filter(|i| i.def_id == *item_def_id)
                             .next()
-                            .and_then(|assoc_item| bounds.iter()
-                                    .filter(|b| b.ident == assoc_item.ident)
+                                .and_then(|trait_assoc_item| impl_items.iter()
+                                    .filter(|i| i.ident == trait_assoc_item.ident)
                                     .next()
-                                    .map(|bound| (bound, assoc_item)))
+                                    .map(|impl_item| (impl_item, trait_assoc_item)))
                         {
-                            cause.span = bound.span;
-                            cause.code = traits::AssocTypeBound(item_span, assoc_item.ident.span);
+                                cause.span = impl_item.span;
+                                cause.code = traits::AssocTypeBound(
+                                    item_span,
+                                    trait_assoc_item.ident.span,
+                                );
+                            }
                         }
                     }
+                    _ => {}
                 }
                 traits::Obligation::new(cause, param_env, pred)
             });

src/test/ui/associated-types/point-at-type-on-obligation-failure-2.rs

@@ -0,0 +1,11 @@
+trait Bar {}
+
+trait Foo {
+    type Assoc: Bar;
+}
+
+impl Foo for () {
+    type Assoc = bool; //~ ERROR the trait bound `bool: Bar` is not satisfied
+}
+
+fn main() {}

src/test/ui/associated-types/point-at-type-on-obligation-failure-2.stderr

@@ -0,0 +1,15 @@
+error[E0277]: the trait bound `bool: Bar` is not satisfied
+  --> $DIR/point-at-type-on-obligation-failure-2.rs:8:5
+   |
+LL |       type Assoc: Bar;
+   |            ----- associated type defined here
+...
+LL | / impl Foo for () {
+LL | |     type Assoc = bool;
+   | |     ^^^^^^^^^^^^^^^^^^ the trait `Bar` is not implemented for `bool`
+LL | | }
+   | |_- in this `impl` item
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.

src/test/ui/associated-types/point-at-type-on-obligation-failure.rs

@@ -0,0 +1,20 @@
+trait Bar {
+    type Ok;
+    type Sibling: Bar2<Ok=Self::Ok>;
+}
+trait Bar2 {
+    type Ok;
+}
+
+struct Foo;
+struct Foo2;
+
+impl Bar for Foo {
+    type Ok = ();  //~ ERROR type mismatch resolving `<Foo2 as Bar2>::Ok == ()`
+    type Sibling = Foo2;
+}
+impl Bar2 for Foo2 {
+    type Ok = u32;
+}
+
+fn main() {}

src/test/ui/associated-types/point-at-type-on-obligation-failure.stderr

@@ -0,0 +1,19 @@
+error[E0271]: type mismatch resolving `<Foo2 as Bar2>::Ok == ()`
+  --> $DIR/point-at-type-on-obligation-failure.rs:13:5
+   |
+LL |       type Ok;
+   |            -- associated type defined here
+...
+LL | / impl Bar for Foo {
+LL | |     type Ok = ();
+   | |     ^^^^^^^^^^^^^ expected u32, found ()
+LL | |     type Sibling = Foo2;
+LL | | }
+   | |_- in this `impl` item
+   |
+   = note: expected type `u32`
+              found type `()`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0271`.