3 files changed, 141 insertions, 17 deletions

diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 42713928f..d5154f436 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -337,17 +337,17 @@ impl Ty {
                     TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty);
                 let ty = if remaining_segments.len() == 1 {
                     let segment = remaining_segments.first().unwrap();
-                    let associated_ty = associated_type_by_name_including_super_traits(
-                        ctx.db.upcast(),
-                        trait_ref.trait_,
+                    let found = associated_type_by_name_including_super_traits(
+                        ctx.db,
+                        trait_ref.clone(),
                         &segment.name,
                     );
-                    match associated_ty {
-                        Some(associated_ty) => {
+                    match found {
+                        Some((super_trait_ref, associated_ty)) => {
                             // FIXME handle type parameters on the segment
                             Ty::Projection(ProjectionTy {
                                 associated_ty,
-                                parameters: trait_ref.substs,
+                                parameters: super_trait_ref.substs,
                             })
                         }
                         None => {
@@ -467,6 +467,9 @@ impl Ty {
                             }
                             TypeParamLoweringMode::Variable => t.substs.clone(),
                         };
+                        // We need to shift in the bound vars, since
+                        // associated_type_shorthand_candidates does not do that
+                        let substs = substs.shift_bound_vars(ctx.in_binders);
                         // FIXME handle type parameters on the segment
                         return Some(Ty::Projection(ProjectionTy {
                             associated_ty,
@@ -706,17 +709,17 @@ fn assoc_type_bindings_from_type_bound<'a>(
         .flat_map(|segment| segment.args_and_bindings.into_iter())
         .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
         .flat_map(move |binding| {
-            let associated_ty = associated_type_by_name_including_super_traits(
-                ctx.db.upcast(),
-                trait_ref.trait_,
+            let found = associated_type_by_name_including_super_traits(
+                ctx.db,
+                trait_ref.clone(),
                 &binding.name,
             );
-            let associated_ty = match associated_ty {
+            let (super_trait_ref, associated_ty) = match found {
                 None => return SmallVec::<[GenericPredicate; 1]>::new(),
                 Some(t) => t,
             };
             let projection_ty =
-                ProjectionTy { associated_ty, parameters: trait_ref.substs.clone() };
+                ProjectionTy { associated_ty, parameters: super_trait_ref.substs.clone() };
             let mut preds = SmallVec::with_capacity(
                 binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
             );
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index ed43df484..4da2e972b 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -665,3 +665,122 @@ impl Foo<i64> {
     "###
     );
 }
+
+#[test]
+fn issue_4931() {
+    assert_snapshot!(
+        infer(r#"
+trait Div<T> {
+    type Output;
+}
+
+trait CheckedDiv: Div<()> {}
+
+trait PrimInt: CheckedDiv<Output = ()> {
+    fn pow(self);
+}
+
+fn check<T: PrimInt>(i: T) {
+    i.pow();
+}
+"#),
+        @r###"
+    118..122 'self': Self
+    149..150 'i': T
+    155..171 '{     ...w(); }': ()
+    161..162 'i': T
+    161..168 'i.pow()': ()
+    "###
+    );
+}
+
+#[test]
+fn issue_4885() {
+    assert_snapshot!(
+        infer(r#"
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T> {}
+
+trait Future {
+    type Output;
+}
+trait Foo<R> {
+    type Bar;
+}
+fn foo<R, K>(key: &K) -> impl Future<Output = K::Bar>
+where
+    K: Foo<R>,
+{
+    bar(key)
+}
+fn bar<R, K>(key: &K) -> impl Future<Output = K::Bar>
+where
+    K: Foo<R>,
+{
+}
+"#),
+        @r###"
+    137..140 'key': &K
+    199..215 '{     ...key) }': impl Future<Output = <K as Foo<R>>::Bar>
+    205..208 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar>
+    205..213 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar>
+    209..212 'key': &K
+    229..232 'key': &K
+    291..294 '{ }': ()
+    "###
+    );
+}
+
+#[test]
+fn issue_4800() {
+    assert_snapshot!(
+        infer(r#"
+trait Debug {}
+
+struct Foo<T>;
+
+type E1<T> = (T, T, T);
+type E2<T> = E1<E1<E1<(T, T, T)>>>;
+
+impl Debug for Foo<E2<()>> {}
+
+struct Request;
+
+pub trait Future {
+    type Output;
+}
+
+pub struct PeerSet<D>;
+
+impl<D> Service<Request> for PeerSet<D>
+where
+    D: Discover,
+    D::Key: Debug,
+{
+    type Error = ();
+    type Future = dyn Future<Output = Self::Error>;
+
+    fn call(&mut self) -> Self::Future {
+        loop {}
+    }
+}
+
+pub trait Discover {
+    type Key;
+}
+
+pub trait Service<Request> {
+    type Error;
+    type Future: Future<Output = Self::Error>;
+    fn call(&mut self) -> Self::Future;
+}
+"#),
+        @r###"
+    380..384 'self': &mut PeerSet<D>
+    402..425 '{     ...     }': dyn Future<Output = ()>
+    412..419 'loop {}': !
+    417..419 '{}': ()
+    576..580 'self': &mut Self
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index f98350bf9..c45820ff0 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -143,13 +143,14 @@ pub(super) fn find_super_trait_path(
 }
 
 pub(super) fn associated_type_by_name_including_super_traits(
-    db: &dyn DefDatabase,
-    trait_: TraitId,
+    db: &dyn HirDatabase,
+    trait_ref: TraitRef,
     name: &Name,
-) -> Option<TypeAliasId> {
-    all_super_traits(db, trait_)
-        .into_iter()
-        .find_map(|t| db.trait_data(t).associated_type_by_name(name))
+) -> Option<(TraitRef, TypeAliasId)> {
+    all_super_trait_refs(db, trait_ref).into_iter().find_map(|t| {
+        let assoc_type = db.trait_data(t.trait_).associated_type_by_name(name)?;
+        Some((t, assoc_type))
+    })
 }
 
 pub(super) fn variant_data(db: &dyn DefDatabase, var: VariantId) -> Arc<VariantData> {
@@ -176,6 +177,7 @@ pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {
     Generics { def, params: db.generic_params(def), parent_generics }
 }
 
+#[derive(Debug)]
 pub(crate) struct Generics {
     def: GenericDefId,
     pub(crate) params: Arc<GenericParams>,