10 files changed, 553 insertions, 50 deletions

diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index 2c7298714..ebd9cb08f 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -6,7 +6,7 @@ use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
 use stdx::format_to;
 
-pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm};
+pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm, path::Path};
 pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
 
 #[derive(Debug)]
@@ -29,6 +29,16 @@ impl Diagnostic for NoSuchField {
     }
 }
 
+impl AstDiagnostic for NoSuchField {
+    type AST = ast::RecordField;
+
+    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+        let root = db.parse_or_expand(self.source().file_id).unwrap();
+        let node = self.source().value.to_node(&root);
+        ast::RecordField::cast(node).unwrap()
+    }
+}
+
 #[derive(Debug)]
 pub struct MissingFields {
     pub file: HirFileId,
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 9fd310f69..a9565a58d 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -10,12 +10,12 @@ use hir_def::{
     resolver::resolver_for_expr,
     AdtId, AssocContainerId, FieldId, Lookup,
 };
-use hir_expand::name::Name;
+use hir_expand::name::{name, Name};
 use ra_syntax::ast::RangeOp;
 
 use crate::{
     autoderef, method_resolution, op,
-    traits::InEnvironment,
+    traits::{FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
     ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
     TraitRef, Ty, TypeCtor,
@@ -63,6 +63,58 @@ impl<'a> InferenceContext<'a> {
         self.resolve_ty_as_possible(ty)
     }
 
+    fn callable_sig_from_fn_trait(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        let krate = self.resolver.krate()?;
+        let fn_once_trait = FnTrait::FnOnce.get_id(self.db, krate)?;
+        let output_assoc_type =
+            self.db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
+        let generic_params = generics(self.db.upcast(), fn_once_trait.into());
+        if generic_params.len() != 2 {
+            return None;
+        }
+
+        let mut param_builder = Substs::builder(num_args);
+        let mut arg_tys = vec![];
+        for _ in 0..num_args {
+            let arg = self.table.new_type_var();
+            param_builder = param_builder.push(arg.clone());
+            arg_tys.push(arg);
+        }
+        let parameters = param_builder.build();
+        let arg_ty = Ty::Apply(ApplicationTy {
+            ctor: TypeCtor::Tuple { cardinality: num_args as u16 },
+            parameters,
+        });
+        let substs = Substs::build_for_generics(&generic_params)
+            .push(ty.clone())
+            .push(arg_ty.clone())
+            .build();
+
+        let trait_env = Arc::clone(&self.trait_env);
+        let implements_fn_trait =
+            Obligation::Trait(TraitRef { trait_: fn_once_trait, substs: substs.clone() });
+        let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
+            value: implements_fn_trait.clone(),
+            environment: trait_env,
+        });
+        if self.db.trait_solve(krate, goal.value).is_some() {
+            self.obligations.push(implements_fn_trait);
+            let output_proj_ty =
+                crate::ProjectionTy { associated_ty: output_assoc_type, parameters: substs };
+            let return_ty = self.normalize_projection_ty(output_proj_ty);
+            Some((arg_tys, return_ty))
+        } else {
+            None
+        }
+    }
+
+    pub fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        match ty.callable_sig(self.db) {
+            Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())),
+            None => self.callable_sig_from_fn_trait(ty, num_args),
+        }
+    }
+
     fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         let ty = match &body[tgt_expr] {
@@ -198,14 +250,23 @@ impl<'a> InferenceContext<'a> {
             }
             Expr::Call { callee, args } => {
                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
-                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
-                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
-                    None => {
-                        // Not callable
-                        // FIXME: report an error
-                        (Vec::new(), Ty::Unknown)
-                    }
-                };
+                let canonicalized = self.canonicalizer().canonicalize_ty(callee_ty.clone());
+                let mut derefs = autoderef(
+                    self.db,
+                    self.resolver.krate(),
+                    InEnvironment {
+                        value: canonicalized.value.clone(),
+                        environment: self.trait_env.clone(),
+                    },
+                );
+                let (param_tys, ret_ty): (Vec<Ty>, Ty) = derefs
+                    .find_map(|callee_deref_ty| {
+                        self.callable_sig(
+                            &canonicalized.decanonicalize_ty(callee_deref_ty.value),
+                            args.len(),
+                        )
+                    })
+                    .unwrap_or((Vec::new(), Ty::Unknown));
                 self.register_obligations_for_call(&callee_ty);
                 self.check_call_arguments(args, &param_tys);
                 self.normalize_associated_types_in(ret_ty)
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 1ad0d8397..80d7ed10e 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -81,7 +81,7 @@ impl<'a> InferenceContext<'a> {
                 let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
                 let substs = Substs::type_params_for_generics(&generics);
                 let ty = self.db.impl_self_ty(impl_id).subst(&substs);
-                if let Some((AdtId::StructId(struct_id), _)) = ty.as_adt() {
+                if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                     let ty = self.db.value_ty(struct_id.into()).subst(&substs);
                     return Some(ty);
                 } else {
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 2b9372b4b..f22232324 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -73,6 +73,7 @@ pub use lower::{
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
 pub use chalk_ir::{BoundVar, DebruijnIndex};
+use itertools::Itertools;
 
 /// A type constructor or type name: this might be something like the primitive
 /// type `bool`, a struct like `Vec`, or things like function pointers or
@@ -815,6 +816,11 @@ impl Ty {
         }
     }
 
+    /// If this is a `dyn Trait`, returns that trait.
+    pub fn dyn_trait(&self) -> Option<TraitId> {
+        self.dyn_trait_ref().map(|it| it.trait_)
+    }
+
     fn builtin_deref(&self) -> Option<Ty> {
         match self {
             Ty::Apply(a_ty) => match a_ty.ctor {
@@ -867,13 +873,56 @@ impl Ty {
         }
     }
 
-    /// If this is a `dyn Trait`, returns that trait.
-    pub fn dyn_trait(&self) -> Option<TraitId> {
+    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
         match self {
-            Ty::Dyn(predicates) => predicates.iter().find_map(|pred| match pred {
-                GenericPredicate::Implemented(tr) => Some(tr.trait_),
-                _ => None,
-            }),
+            Ty::Opaque(opaque_ty) => {
+                let predicates = match opaque_ty.opaque_ty_id {
+                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
+                        db.return_type_impl_traits(func).map(|it| {
+                            let data = (*it)
+                                .as_ref()
+                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                            data.clone().subst(&opaque_ty.parameters)
+                        })
+                    }
+                };
+
+                predicates.map(|it| it.value)
+            }
+            Ty::Placeholder(id) => {
+                let generic_params = db.generic_params(id.parent);
+                let param_data = &generic_params.types[id.local_id];
+                match param_data.provenance {
+                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let predicates = db
+                            .generic_predicates_for_param(*id)
+                            .into_iter()
+                            .map(|pred| pred.value.clone())
+                            .collect_vec();
+
+                        Some(predicates)
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
+        match self {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::AssociatedType(type_alias_id), .. }) => {
+                match type_alias_id.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
+            Ty::Projection(projection_ty) => {
+                match projection_ty.associated_ty.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
             _ => None,
         }
     }
@@ -1057,5 +1106,5 @@ pub struct ReturnTypeImplTraits {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
+    pub bounds: Binders<Vec<GenericPredicate>>,
 }
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 1f004bd63..4da2e972b 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -633,3 +633,154 @@ where
     "###
     );
 }
+
+#[test]
+fn issue_4953() {
+    assert_snapshot!(
+        infer(r#"
+pub struct Foo(pub i64);
+impl Foo {
+    fn test() -> Self { Self(0i64) }
+}
+"#),
+        @r###"
+    59..73 '{ Self(0i64) }': Foo
+    61..65 'Self': Foo(i64) -> Foo
+    61..71 'Self(0i64)': Foo
+    66..70 '0i64': i64
+    "###
+    );
+    assert_snapshot!(
+        infer(r#"
+pub struct Foo<T>(pub T);
+impl Foo<i64> {
+    fn test() -> Self { Self(0i64) }
+}
+"#),
+        @r###"
+    65..79 '{ Self(0i64) }': Foo<i64>
+    67..71 'Self': Foo<i64>(i64) -> Foo<i64>
+    67..77 'Self(0i64)': Foo<i64>
+    72..76 '0i64': 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/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index e81193a3c..961be4abd 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -2888,3 +2888,226 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
     );
     assert_eq!(t, "i32");
 }
+
+#[test]
+fn infer_closure_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo() {
+                let s = Option::None;
+                let f = |x: Option<i32>| {};
+                (&f)(s)
+            }
+        "#
+        ),
+        @r###"
+    137..259 '{     ...     }': ()
+    159..160 's': Option<i32>
+    163..175 'Option::None': Option<i32>
+    197..198 'f': |Option<i32>| -> ()
+    201..220 '|x: Op...2>| {}': |Option<i32>| -> ()
+    202..203 'x': Option<i32>
+    218..220 '{}': ()
+    238..245 '(&f)(s)': ()
+    239..241 '&f': &|Option<i32>| -> ()
+    240..241 'f': |Option<i32>| -> ()
+    243..244 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_fn_trait_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo<F, T>(f: F) -> T
+            where
+                F: Fn(Option<i32>) -> T,
+            {
+                let s = None;
+                f(s)
+            }
+        "#
+        ),
+        @r###"
+    183..187 'self': &Self
+    189..193 'args': Args
+    350..354 'self': &Self
+    356..360 'args': Args
+    515..516 'f': F
+    597..663 '{     ...     }': T
+    619..620 's': Option<i32>
+    623..627 'None': Option<i32>
+    645..646 'f': F
+    645..649 'f(s)': T
+    647..648 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_box_fn_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+
+                fn deref(&self) -> &Self::Target;
+            }
+
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo() {
+                let s = Option::None;
+                let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
+                f(&s)
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    356..360 'self': &Self
+    622..626 'self': &Box<T>
+    634..685 '{     ...     }': &T
+    656..667 '&self.inner': &*mut T
+    657..661 'self': &Box<T>
+    657..667 'self.inner': *mut T
+    812..957 '{     ...     }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    834..835 's': Option<i32>
+    838..850 'Option::None': Option<i32>
+    872..873 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    907..920 'box (|ps| {})': Box<|{unknown}| -> ()>
+    912..919 '|ps| {}': |{unknown}| -> ()
+    913..915 'ps': {unknown}
+    917..919 '{}': ()
+    938..939 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    938..943 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    940..942 '&s': &Option<i32>
+    941..942 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_dyn_fn_output() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+
+                fn deref(&self) -> &Self::Target;
+            }
+
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+
+            fn foo() {
+                let f: Box<dyn Fn() -> i32> = box(|| 5);
+                let x = f();
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    349..353 'self': &Self
+    355..359 'args': Args
+    523..527 'self': &Self
+    789..793 'self': &Box<T>
+    801..852 '{     ...     }': &T
+    823..834 '&self.inner': &*mut T
+    824..828 'self': &Box<T>
+    824..834 'self.inner': *mut T
+    889..990 '{     ...     }': ()
+    911..912 'f': Box<dyn Fn<(), Output = i32>>
+    937..946 'box(|| 5)': Box<|| -> i32>
+    941..945 '|| 5': || -> i32
+    944..945 '5': i32
+    968..969 'x': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    972..973 'f': Box<dyn Fn<(), Output = i32>>
+    972..975 'f()': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 99d7a9616..6f43c3a22 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -2,7 +2,9 @@
 use std::{panic, sync::Arc};
 
 use chalk_ir::cast::Cast;
-use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
+use hir_def::{
+    expr::ExprId, lang_item::LangItemTarget, DefWithBodyId, ImplId, TraitId, TypeAliasId,
+};
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 
@@ -269,6 +271,14 @@ impl FnTrait {
             FnTrait::Fn => "fn",
         }
     }
+
+    pub fn get_id(&self, db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> {
+        let target = db.lang_item(krate, self.lang_item_name().into())?;
+        match target {
+            LangItemTarget::TraitId(t) => Some(t),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_ty/src/traits/builtin.rs b/crates/ra_hir_ty/src/traits/builtin.rs
index 88a422d2c..6d5f2d46a 100644
--- a/crates/ra_hir_ty/src/traits/builtin.rs
+++ b/crates/ra_hir_ty/src/traits/builtin.rs
@@ -40,7 +40,7 @@ pub(super) fn get_builtin_impls(
     if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { def, expr }, .. }) = ty {
         for &fn_trait in [super::FnTrait::FnOnce, super::FnTrait::FnMut, super::FnTrait::Fn].iter()
         {
-            if let Some(actual_trait) = get_fn_trait(db, krate, fn_trait) {
+            if let Some(actual_trait) = fn_trait.get_id(db, krate) {
                 if trait_ == actual_trait {
                     let impl_ = super::ClosureFnTraitImplData { def: *def, expr: *expr, fn_trait };
                     if check_closure_fn_trait_impl_prerequisites(db, krate, impl_) {
@@ -128,7 +128,7 @@ fn check_closure_fn_trait_impl_prerequisites(
     data: super::ClosureFnTraitImplData,
 ) -> bool {
     // the respective Fn/FnOnce/FnMut trait needs to exist
-    if get_fn_trait(db, krate, data.fn_trait).is_none() {
+    if data.fn_trait.get_id(db, krate).is_none() {
         return false;
     }
 
@@ -136,7 +136,7 @@ fn check_closure_fn_trait_impl_prerequisites(
     // the traits having no type params, FnOnce being a supertrait
 
     // the FnOnce trait needs to exist and have an assoc type named Output
-    let fn_once_trait = match get_fn_trait(db, krate, super::FnTrait::FnOnce) {
+    let fn_once_trait = match (super::FnTrait::FnOnce).get_id(db, krate) {
         Some(t) => t,
         None => return false,
     };
@@ -151,7 +151,9 @@ fn closure_fn_trait_impl_datum(
     // for some closure |X, Y| -> Z:
     // impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V }
 
-    let trait_ = get_fn_trait(db, krate, data.fn_trait) // get corresponding fn trait
+    let trait_ = data
+        .fn_trait
+        .get_id(db, krate) // get corresponding fn trait
         // the existence of the Fn trait has been checked before
         .expect("fn trait for closure impl missing");
 
@@ -211,7 +213,7 @@ fn closure_fn_trait_output_assoc_ty_value(
     let output_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, num_args.into()));
 
     let fn_once_trait =
-        get_fn_trait(db, krate, super::FnTrait::FnOnce).expect("assoc ty value should not exist");
+        (super::FnTrait::FnOnce).get_id(db, krate).expect("assoc ty value should not exist");
 
     let output_ty_id = db
         .trait_data(fn_once_trait)
@@ -360,14 +362,6 @@ fn super_trait_object_unsize_impl_datum(
     BuiltinImplData { num_vars, trait_ref, where_clauses: Vec::new(), assoc_ty_values: Vec::new() }
 }
 
-fn get_fn_trait(db: &dyn HirDatabase, krate: CrateId, fn_trait: super::FnTrait) -> Option<TraitId> {
-    let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
-    match target {
-        LangItemTarget::TraitId(t) => Some(t),
-        _ => None,
-    }
-}
-
 fn get_unsize_trait(db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> {
     let target = db.lang_item(krate, "unsize".into())?;
     match target {
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>,