6 files changed, 440 insertions, 203 deletions
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index ab5f008ef..a442a856c 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -3,7 +3,7 @@
 //! reference to a type with the field `bar`. This is an approximation of the
 //! logic in rustc (which lives in librustc_typeck/check/autoderef.rs).
-use ra_syntax::algo::generate;
+use std::iter::successors;
 use crate::HirDatabase;
 use super::Ty;
@@ -11,7 +11,7 @@ use super::Ty;
 impl Ty {
    /// Iterates over the possible derefs of `ty`.
    pub fn autoderef<'a>(self, db: &'a impl HirDatabase) -> impl Iterator<Item = Ty> + 'a {
-        generate(Some(self), move |ty| ty.autoderef_step(db))
+        successors(Some(self), move |ty| ty.autoderef_step(db))
    }
    fn autoderef_step(&self, _db: &impl HirDatabase) -> Option<Ty> {
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 28947be51..651a78fe5 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -20,9 +20,9 @@ use std::sync::Arc;
 use std::mem;
 use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
-use ra_arena::map::ArenaMap;
 use rustc_hash::FxHashMap;
+use ra_arena::map::ArenaMap;
 use test_utils::tested_by;
 use crate::{
@@ -33,15 +33,18 @@ use crate::{
    ImplItem,
    type_ref::{TypeRef, Mutability},
    expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat,Array, self},
-    generics::GenericParams,
+    generics::{GenericParams, HasGenericParams},
    path::{GenericArgs, GenericArg},
    adt::VariantDef,
    resolve::{Resolver, Resolution},
    nameres::Namespace,
-    ty::infer::diagnostics::InferenceDiagnostic,
    diagnostics::DiagnosticSink,
 };
-use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeCtor};
+use super::{
+    Ty, TypableDef, Substs, primitive, op, ApplicationTy, TypeCtor, CallableDef, TraitRef,
+    traits::{ Solution, Obligation, Guidance},
+};
+use self::diagnostics::InferenceDiagnostic;
 /// The entry point of type inference.
 pub fn infer(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
@@ -153,6 +156,7 @@ struct InferenceContext<'a, D: HirDatabase> {
    body: Arc<Body>,
    resolver: Resolver,
    var_unification_table: InPlaceUnificationTable<TypeVarId>,
+    obligations: Vec<Obligation>,
    method_resolutions: FxHashMap<ExprId, Function>,
    field_resolutions: FxHashMap<ExprId, StructField>,
    assoc_resolutions: FxHashMap<ExprOrPatId, ImplItem>,
@@ -173,6 +177,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            type_of_pat: ArenaMap::default(),
            diagnostics: Vec::default(),
            var_unification_table: InPlaceUnificationTable::new(),
+            obligations: Vec::default(),
            return_ty: Ty::Unknown, // set in collect_fn_signature
            db,
            body,
@@ -181,6 +186,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn resolve_all(mut self) -> InferenceResult {
+        // FIXME resolve obligations as well (use Guidance if necessary)
        let mut tv_stack = Vec::new();
        let mut expr_types = mem::replace(&mut self.type_of_expr, ArenaMap::default());
        for ty in expr_types.values_mut() {
@@ -311,11 +317,49 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        ty.fold(&mut |ty| self.insert_type_vars_shallow(ty))
    }
+    fn resolve_obligations_as_possible(&mut self) {
+        let obligations = mem::replace(&mut self.obligations, Vec::new());
+        for obligation in obligations {
+            // FIXME resolve types in the obligation first
+            let (solution, var_mapping) = match &obligation {
+                Obligation::Trait(tr) => {
+                    let (tr, var_mapping) = super::traits::canonicalize(tr.clone());
+                    (self.db.implements(tr), var_mapping)
+                }
+            };
+            match solution {
+                Some(Solution::Unique(substs)) => {
+                    for (i, subst) in substs.0.iter().enumerate() {
+                        let uncanonical = var_mapping[i];
+                        // FIXME the subst may contain type variables, which would need to be mapped back as well
+                        self.unify(&Ty::Infer(InferTy::TypeVar(uncanonical)), subst);
+                    }
+                }
+                Some(Solution::Ambig(Guidance::Definite(substs))) => {
+                    for (i, subst) in substs.0.iter().enumerate() {
+                        let uncanonical = var_mapping[i];
+                        // FIXME the subst may contain type variables, which would need to be mapped back as well
+                        self.unify(&Ty::Infer(InferTy::TypeVar(uncanonical)), subst);
+                    }
+                    self.obligations.push(obligation);
+                }
+                Some(_) => {
+                    self.obligations.push(obligation);
+                }
+                None => {
+                    // FIXME obligation cannot be fulfilled => diagnostic
+                }
+            }
+        }
+    }
    /// Resolves the type as far as currently possible, replacing type variables
    /// by their known types. All types returned by the infer_* functions should
    /// be resolved as far as possible, i.e. contain no type variables with
    /// known type.
    fn resolve_ty_as_possible(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
+        self.resolve_obligations_as_possible();
        ty.fold(&mut |ty| match ty {
            Ty::Infer(tv) => {
                let inner = tv.to_inner();
@@ -420,6 +464,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        for segment in &path.segments[remaining_index..] {
            let ty = match resolved {
                Resolution::Def(def) => {
+                    // FIXME resolve associated items from traits as well
                    let typable: Option<TypableDef> = def.into();
                    let typable = typable?;
@@ -709,13 +754,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn substs_for_method_call(
        &mut self,
        def_generics: Option<Arc<GenericParams>>,
-        generic_args: &Option<GenericArgs>,
+        generic_args: Option<&GenericArgs>,
+        receiver_ty: &Ty,
    ) -> Substs {
        let (parent_param_count, param_count) =
-            def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len()));
+            def_generics.as_ref().map_or((0, 0), |g| (g.count_parent_params(), g.params.len()));
        let mut substs = Vec::with_capacity(parent_param_count + param_count);
-        for _ in 0..parent_param_count {
+        // Parent arguments are unknown, except for the receiver type
-            substs.push(Ty::Unknown);
+        if let Some(parent_generics) = def_generics.and_then(|p| p.parent_params.clone()) {
+            for param in &parent_generics.params {
+                if param.name.as_known_name() == Some(crate::KnownName::SelfType) {
+                    substs.push(receiver_ty.clone());
+                } else {
+                    substs.push(Ty::Unknown);
+                }
+            }
        }
        // handle provided type arguments
        if let Some(generic_args) = generic_args {
@@ -737,6 +790,83 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        Substs(substs.into())
    }
+    fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
+        match callable_ty {
+            Ty::Apply(a_ty) => match a_ty.ctor {
+                TypeCtor::FnDef(def) => {
+                    // add obligation for trait implementation, if this is a trait method
+                    // FIXME also register obligations from where clauses from the trait or impl and method
+                    match def {
+                        CallableDef::Function(f) => {
+                            if let Some(trait_) = f.parent_trait(self.db) {
+                                // construct a TraitDef
+                                let substs = a_ty.parameters.prefix(
+                                    trait_.generic_params(self.db).count_params_including_parent(),
+                                );
+                                self.obligations
+                                    .push(Obligation::Trait(TraitRef { trait_, substs }));
+                            }
+                        }
+                        CallableDef::Struct(_) | CallableDef::EnumVariant(_) => {}
+                    }
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+    }
+    fn infer_method_call(
+        &mut self,
+        tgt_expr: ExprId,
+        receiver: ExprId,
+        args: &[ExprId],
+        method_name: &Name,
+        generic_args: Option<&GenericArgs>,
+    ) -> Ty {
+        let receiver_ty = self.infer_expr(receiver, &Expectation::none());
+        let resolved = receiver_ty.clone().lookup_method(self.db, method_name, &self.resolver);
+        let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
+            Some((ty, func)) => {
+                self.write_method_resolution(tgt_expr, func);
+                (
+                    ty,
+                    self.db.type_for_def(func.into(), Namespace::Values),
+                    Some(func.generic_params(self.db)),
+                )
+            }
+            None => (receiver_ty, Ty::Unknown, None),
+        };
+        let substs =
+            self.substs_for_method_call(def_generics.clone(), generic_args, &derefed_receiver_ty);
+        let method_ty = method_ty.apply_substs(substs);
+        let method_ty = self.insert_type_vars(method_ty);
+        self.register_obligations_for_call(&method_ty);
+        let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
+            Some(sig) => {
+                if !sig.params().is_empty() {
+                    (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
+                } else {
+                    (Ty::Unknown, Vec::new(), sig.ret().clone())
+                }
+            }
+            None => (Ty::Unknown, Vec::new(), Ty::Unknown),
+        };
+        // Apply autoref so the below unification works correctly
+        // FIXME: return correct autorefs from lookup_method
+        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
+            Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
+            _ => derefed_receiver_ty,
+        };
+        self.unify(&expected_receiver_ty, &actual_receiver_ty);
+        let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
+        for (arg, param) in args.iter().zip(param_iter) {
+            self.infer_expr(*arg, &Expectation::has_type(param));
+        }
+        ret_ty
+    }
    fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        let ty = match &body[tgt_expr] {
@@ -793,102 +923,23 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            }
            Expr::Call { callee, args } => {
                let callee_ty = self.infer_expr(*callee, &Expectation::none());
-                let (param_tys, ret_ty) = match &callee_ty {
+                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
-                    Ty::Apply(a_ty) => match a_ty.ctor {
+                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
-                        TypeCtor::FnPtr => {
+                    None => {
-                            let sig = FnSig::from_fn_ptr_substs(&a_ty.parameters);
+                        // Not callable
-                            (sig.params().to_vec(), sig.ret().clone())
+                        // FIXME: report an error
-                        }
-                        TypeCtor::FnDef(def) => {
-                            let sig = self.db.callable_item_signature(def);
-                            let ret_ty = sig.ret().clone().subst(&a_ty.parameters);
-                            let param_tys = sig
-                                .params()
-                                .iter()
-                                .map(|ty| ty.clone().subst(&a_ty.parameters))
-                                .collect();
-                            (param_tys, ret_ty)
-                        }
-                        _ => (Vec::new(), Ty::Unknown),
-                    },
-                    _ => {
-                        // not callable
-                        // FIXME report an error?
                        (Vec::new(), Ty::Unknown)
                    }
                };
+                // FIXME register obligations from where clauses from the function
                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
                for (arg, param) in args.iter().zip(param_iter) {
                    self.infer_expr(*arg, &Expectation::has_type(param));
                }
                ret_ty
            }
-            Expr::MethodCall { receiver, args, method_name, generic_args } => {
+            Expr::MethodCall { receiver, args, method_name, generic_args } => self
-                let receiver_ty = self.infer_expr(*receiver, &Expectation::none());
+                .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
-                let resolved =
-                    receiver_ty.clone().lookup_method(self.db, method_name, &self.resolver);
-                let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
-                    Some((ty, func)) => {
-                        self.write_method_resolution(tgt_expr, func);
-                        (
-                            ty,
-                            self.db.type_for_def(func.into(), Namespace::Values),
-                            Some(func.generic_params(self.db)),
-                        )
-                    }
-                    None => (receiver_ty, Ty::Unknown, None),
-                };
-                let substs = self.substs_for_method_call(def_generics, generic_args);
-                let method_ty = method_ty.apply_substs(substs);
-                let method_ty = self.insert_type_vars(method_ty);
-                let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
-                    Ty::Apply(a_ty) => match a_ty.ctor {
-                        TypeCtor::FnPtr => {
-                            let sig = FnSig::from_fn_ptr_substs(&a_ty.parameters);
-                            if !sig.params().is_empty() {
-                                (
-                                    sig.params()[0].clone(),
-                                    sig.params()[1..].to_vec(),
-                                    sig.ret().clone(),
-                                )
-                            } else {
-                                (Ty::Unknown, Vec::new(), sig.ret().clone())
-                            }
-                        }
-                        TypeCtor::FnDef(def) => {
-                            let sig = self.db.callable_item_signature(def);
-                            let ret_ty = sig.ret().clone().subst(&a_ty.parameters);
-                            if !sig.params().is_empty() {
-                                let mut params_iter = sig
-                                    .params()
-                                    .iter()
-                                    .map(|ty| ty.clone().subst(&a_ty.parameters));
-                                let receiver_ty = params_iter.next().unwrap();
-                                (receiver_ty, params_iter.collect(), ret_ty)
-                            } else {
-                                (Ty::Unknown, Vec::new(), ret_ty)
-                            }
-                        }
-                        _ => (Ty::Unknown, Vec::new(), Ty::Unknown),
-                    },
-                    _ => (Ty::Unknown, Vec::new(), Ty::Unknown),
-                };
-                // Apply autoref so the below unification works correctly
-                let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-                    Some((_, mutability)) => {
-                        Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty)
-                    }
-                    _ => derefed_receiver_ty,
-                };
-                self.unify(&expected_receiver_ty, &actual_receiver_ty);
-                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
-                for (arg, param) in args.iter().zip(param_iter) {
-                    self.infer_expr(*arg, &Expectation::has_type(param));
-                }
-                ret_ty
-            }
            Expr::Match { expr, arms } => {
                let expected = if expected.ty == Ty::Unknown {
                    Expectation::has_type(self.new_type_var())
@@ -1180,7 +1231,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 /// The ID of a type variable.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub struct TypeVarId(u32);
+pub struct TypeVarId(pub(super) u32);
 impl UnifyKey for TypeVarId {
    type Value = TypeVarValue;
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 003a89f0d..7fac084ce 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -5,6 +5,7 @@
 //!  - Building the type for an item: This happens through the `type_for_def` query.
 //!
 //! This usually involves resolving names, collecting generic arguments etc.
+use std::iter;
 use crate::{
    Function, Struct, StructField, Enum, EnumVariant, Path,
@@ -15,11 +16,11 @@ use crate::{
    name::KnownName,
    nameres::Namespace,
    resolve::{Resolver, Resolution},
-    path::{ PathSegment, GenericArg},
+    path::{PathSegment, GenericArg},
-    generics::GenericParams,
+    generics::{GenericParams, HasGenericParams},
-    adt::VariantDef,
+    adt::VariantDef, Trait
 };
-use super::{Ty, primitive, FnSig, Substs, TypeCtor};
+use super::{Ty, primitive, FnSig, Substs, TypeCtor, TraitRef};
 impl Ty {
    pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
@@ -115,7 +116,6 @@ impl Ty {
        segment: &PathSegment,
        resolved: TypableDef,
    ) -> Substs {
-        let mut substs = Vec::new();
        let def_generics = match resolved {
            TypableDef::Function(func) => func.generic_params(db),
            TypableDef::Struct(s) => s.generic_params(db),
@@ -124,28 +124,7 @@ impl Ty {
            TypableDef::TypeAlias(t) => t.generic_params(db),
            TypableDef::Const(_) | TypableDef::Static(_) => GenericParams::default().into(),
        };
-        let parent_param_count = def_generics.count_parent_params();
+        substs_from_path_segment(db, resolver, segment, &def_generics, false)
-        substs.extend((0..parent_param_count).map(|_| Ty::Unknown));
-        if let Some(generic_args) = &segment.args_and_bindings {
-            // if args are provided, it should be all of them, but we can't rely on that
-            let param_count = def_generics.params.len();
-            for arg in generic_args.args.iter().take(param_count) {
-                match arg {
-                    GenericArg::Type(type_ref) => {
-                        let ty = Ty::from_hir(db, resolver, type_ref);
-                        substs.push(ty);
-                    }
-                }
-            }
-        }
-        // add placeholders for args that were not provided
-        // FIXME: handle defaults
-        let supplied_params = substs.len();
-        for _ in supplied_params..def_generics.count_params_including_parent() {
-            substs.push(Ty::Unknown);
-        }
-        assert_eq!(substs.len(), def_generics.count_params_including_parent());
-        Substs(substs.into())
    }
    /// Collect generic arguments from a path into a `Substs`. See also
@@ -185,6 +164,82 @@ impl Ty {
    }
 }
+pub(super) fn substs_from_path_segment(
+    db: &impl HirDatabase,
+    resolver: &Resolver,
+    segment: &PathSegment,
+    def_generics: &GenericParams,
+    add_self_param: bool,
+) -> Substs {
+    let mut substs = Vec::new();
+    let parent_param_count = def_generics.count_parent_params();
+    substs.extend(iter::repeat(Ty::Unknown).take(parent_param_count));
+    if add_self_param {
+        // FIXME this add_self_param argument is kind of a hack: Traits have the
+        // Self type as an implicit first type parameter, but it can't be
+        // actually provided in the type arguments
+        // (well, actually sometimes it can, in the form of type-relative paths: `<Foo as Default>::default()`)
+        substs.push(Ty::Unknown);
+    }
+    if let Some(generic_args) = &segment.args_and_bindings {
+        // if args are provided, it should be all of them, but we can't rely on that
+        let self_param_correction = if add_self_param { 1 } else { 0 };
+        let param_count = def_generics.params.len() - self_param_correction;
+        for arg in generic_args.args.iter().take(param_count) {
+            match arg {
+                GenericArg::Type(type_ref) => {
+                    let ty = Ty::from_hir(db, resolver, type_ref);
+                    substs.push(ty);
+                }
+            }
+        }
+    }
+    // add placeholders for args that were not provided
+    // FIXME: handle defaults
+    let supplied_params = substs.len();
+    for _ in supplied_params..def_generics.count_params_including_parent() {
+        substs.push(Ty::Unknown);
+    }
+    assert_eq!(substs.len(), def_generics.count_params_including_parent());
+    Substs(substs.into())
+}
+impl TraitRef {
+    pub(crate) fn from_hir(
+        db: &impl HirDatabase,
+        resolver: &Resolver,
+        type_ref: &TypeRef,
+        explicit_self_ty: Option<Ty>,
+    ) -> Option<Self> {
+        let path = match type_ref {
+            TypeRef::Path(path) => path,
+            _ => return None,
+        };
+        let resolved = match resolver.resolve_path(db, &path).take_types()? {
+            Resolution::Def(ModuleDef::Trait(tr)) => tr,
+            _ => return None,
+        };
+        let mut substs = Self::substs_from_path(db, resolver, path, resolved);
+        if let Some(self_ty) = explicit_self_ty {
+            // FIXME this could be nicer
+            let mut substs_vec = substs.0.to_vec();
+            substs_vec[0] = self_ty;
+            substs.0 = substs_vec.into();
+        }
+        Some(TraitRef { trait_: resolved, substs })
+    }
+    fn substs_from_path(
+        db: &impl HirDatabase,
+        resolver: &Resolver,
+        path: &Path,
+        resolved: Trait,
+    ) -> Substs {
+        let segment = path.segments.last().expect("path should have at least one segment");
+        substs_from_path_segment(db, resolver, segment, &resolved.generic_params(db), true)
+    }
+}
 /// Build the declared type of an item. This depends on the namespace; e.g. for
 /// `struct Foo(usize)`, we have two types: The type of the struct itself, and
 /// the constructor function `(usize) -> Foo` which lives in the values
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 3ac8dc46b..6b7918187 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -10,10 +10,12 @@ use crate::{
    HirDatabase, Module, Crate, Name, Function, Trait,
    impl_block::{ImplId, ImplBlock, ImplItem},
    ty::{Ty, TypeCtor},
-    nameres::CrateModuleId, resolve::Resolver, traits::TraitItem
+    nameres::CrateModuleId,
+    resolve::Resolver,
+    traits::TraitItem,
+    generics::HasGenericParams,
 };
-use super::{ TraitRef, Substs};
+use super::{TraitRef, Substs};
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -72,9 +74,9 @@ impl CrateImplBlocks {
            let target_ty = impl_block.target_ty(db);
-            if let Some(tr) = impl_block.target_trait(db) {
+            if let Some(tr) = impl_block.target_trait_ref(db) {
                self.impls_by_trait
-                    .entry(tr)
+                    .entry(tr.trait_)
                    .or_insert_with(Vec::new)
                    .push((module.module_id, impl_id));
            } else {
@@ -108,20 +110,6 @@ impl CrateImplBlocks {
    }
 }
-/// Rudimentary check whether an impl exists for a given type and trait; this
-/// will actually be done by chalk.
-pub(crate) fn implements(db: &impl HirDatabase, trait_ref: TraitRef) -> bool {
-    // FIXME use all trait impls in the whole crate graph
-    let krate = trait_ref.trait_.module(db).krate(db);
-    let krate = match krate {
-        Some(krate) => krate,
-        None => return false,
-    };
-    let crate_impl_blocks = db.impls_in_crate(krate);
-    let mut impl_blocks = crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_ref.trait_);
-    impl_blocks.any(|impl_block| &impl_block.target_ty(db) == trait_ref.self_ty())
-}
 fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
    match ty {
        Ty::Apply(a_ty) => match a_ty.ctor {
@@ -135,13 +123,14 @@ fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
 impl Ty {
    /// Look up the method with the given name, returning the actual autoderefed
    /// receiver type (but without autoref applied yet).
-    pub fn lookup_method(
+    pub(crate) fn lookup_method(
        self,
        db: &impl HirDatabase,
        name: &Name,
        resolver: &Resolver,
    ) -> Option<(Ty, Function)> {
        // FIXME: trait methods should be used before autoderefs
+        // (and we need to do autoderefs for trait method calls as well)
        let inherent_method = self.clone().iterate_methods(db, |ty, f| {
            let sig = f.signature(db);
            if sig.name() == name && sig.has_self_param() {
@@ -174,22 +163,15 @@ impl Ty {
                }
            }
        }
-        // FIXME:
-        //  - we might not actually be able to determine fully that the type
-        //    implements the trait here; it's enough if we (well, Chalk) determine
-        //    that it's possible.
-        //  - when the trait method is picked, we need to register an
-        //    'obligation' somewhere so that we later check that it's really
-        //    implemented
-        //  - both points go for additional requirements from where clauses as
-        //    well (in fact, the 'implements' condition could just be considered a
-        //    'where Self: Trait' clause)
        candidates.retain(|(t, _m)| {
-            let trait_ref = TraitRef { trait_: *t, substs: Substs::single(self.clone()) };
+            let trait_ref =
-            db.implements(trait_ref)
+                TraitRef { trait_: *t, substs: fresh_substs_for_trait(db, *t, self.clone()) };
+            let (trait_ref, _) = super::traits::canonicalize(trait_ref);
+            db.implements(trait_ref).is_some()
        });
        // FIXME if there's multiple candidates here, that's an ambiguity error
        let (_chosen_trait, chosen_method) = candidates.first()?;
+        // FIXME return correct receiver type
        Some((self.clone(), *chosen_method))
    }
@@ -252,3 +234,17 @@ impl Ty {
        None
    }
 }
+/// This creates Substs for a trait with the given Self type and type variables
+/// for all other parameters. This is kind of a hack since these aren't 'real'
+/// type variables; the resulting trait reference is just used for the
+/// preliminary method candidate check.
+fn fresh_substs_for_trait(db: &impl HirDatabase, tr: Trait, self_ty: Ty) -> Substs {
+    let mut substs = Vec::new();
+    let generics = tr.generic_params(db);
+    substs.push(self_ty);
+    substs.extend(generics.params_including_parent().into_iter().skip(1).enumerate().map(
+        |(i, _p)| Ty::Infer(super::infer::InferTy::TypeVar(super::infer::TypeVarId(i as u32))),
+    ));
+    substs.into()
+}
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index f6a325033..291bc9ae5 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -4,15 +4,15 @@ use std::fmt::Write;
 use insta::assert_snapshot_matches;
 use ra_db::{SourceDatabase, salsa::Database, FilePosition};
-use ra_syntax::{algo, ast::{self, AstNode}};
+use ra_syntax::{algo, ast::{self, AstNode}, SyntaxKind::*};
 use test_utils::covers;
 use crate::{
-    source_binder,
    mock::MockDatabase,
    ty::display::HirDisplay,
    ty::InferenceResult,
-    expr::BodySourceMap
+    expr::BodySourceMap,
+    SourceAnalyzer,
 };
 // These tests compare the inference results for all expressions in a file
@@ -1862,14 +1862,14 @@ fn test() {
        @r###"
 [49; 50) '0': u32
 [80; 83) '101': u32
-[126; 128) '99': u32
 [95; 213) '{     ...NST; }': ()
 [138; 139) 'x': {unknown}
 [142; 153) 'LOCAL_CONST': {unknown}
 [163; 164) 'z': u32
 [167; 179) 'GLOBAL_CONST': u32
 [189; 191) 'id': u32
-[194; 210) 'Foo::A..._CONST': u32"###
+[194; 210) 'Foo::A..._CONST': u32
+[126; 128) '99': u32"###
    );
 }
@@ -1891,8 +1891,6 @@ fn test() {
        @r###"
 [29; 32) '101': u32
 [70; 73) '101': u32
-[118; 120) '99': u32
-[161; 163) '99': u32
 [85; 280) '{     ...MUT; }': ()
 [173; 174) 'x': {unknown}
 [177; 189) 'LOCAL_STATIC': {unknown}
@@ -1901,7 +1899,9 @@ fn test() {
 [229; 230) 'z': u32
 [233; 246) 'GLOBAL_STATIC': u32
 [256; 257) 'w': u32
-[260; 277) 'GLOBAL...IC_MUT': u32"###
+[260; 277) 'GLOBAL...IC_MUT': u32
+[118; 120) '99': u32
+[161; 163) '99': u32"###
    );
 }
@@ -1926,8 +1926,8 @@ fn test() {
 }
 "#),
        @r###"
-[31; 35) 'self': &{unknown}
+[31; 35) 'self': &Self
-[110; 114) 'self': &{unknown}
+[110; 114) 'self': &Self
 [170; 228) '{     ...i128 }': ()
 [176; 178) 'S1': S1
 [176; 187) 'S1.method()': u32
@@ -1972,8 +1972,8 @@ mod bar_test {
 }
 "#),
        @r###"
-[63; 67) 'self': &{unknown}
+[63; 67) 'self': &Self
-[169; 173) 'self': &{unknown}
+[169; 173) 'self': &Self
 [300; 337) '{     ...     }': ()
 [310; 311) 'S': S
 [310; 320) 'S.method()': u32
@@ -1998,10 +1998,45 @@ fn test() {
 }
 "#),
        @r###"
-[33; 37) 'self': &{unknown}
+[33; 37) 'self': &Self
 [92; 111) '{     ...d(); }': ()
 [98; 99) 'S': S
-[98; 108) 'S.method()': {unknown}"###
+[98; 108) 'S.method()': u32"###
+    );
+}
+#[test]
+fn infer_trait_method_generic_more_params() {
+    // the trait implementation is intentionally incomplete -- it shouldn't matter
+    assert_snapshot_matches!(
+        infer(r#"
+trait Trait<T1, T2, T3> {
+    fn method1(&self) -> (T1, T2, T3);
+    fn method2(&self) -> (T3, T2, T1);
+}
+struct S1;
+impl Trait<u8, u16, u32> for S1 {}
+struct S2;
+impl<T> Trait<i8, i16, T> for S2 {}
+fn test() {
+    S1.method1(); // u8, u16, u32
+    S1.method2(); // u32, u16, u8
+    S2.method1(); // i8, i16, {unknown}
+    S2.method2(); // {unknown}, i16, i8
+}
+"#),
+        @r###"
+[43; 47) 'self': &Self
+[82; 86) 'self': &Self
+[210; 361) '{     ..., i8 }': ()
+[216; 218) 'S1': S1
+[216; 228) 'S1.method1()': (u8, u16, u32)
+[250; 252) 'S1': S1
+[250; 262) 'S1.method2()': (u32, u16, u8)
+[284; 286) 'S2': S2
+[284; 296) 'S2.method1()': (i8, i16, {unknown})
+[324; 326) 'S2': S2
+[324; 336) 'S2.method2()': ({unknown}, i16, i8)"###
    );
 }
@@ -2020,7 +2055,7 @@ fn test() {
 }
 "#),
        @r###"
-[33; 37) 'self': &{unknown}
+[33; 37) 'self': &Self
 [102; 127) '{     ...d(); }': ()
 [108; 109) 'S': S<u32>(T) -> S<T>
 [108; 115) 'S(1u32)': S<u32>
@@ -2168,7 +2203,7 @@ fn test() {
 }
 "#),
        @r###"
-[29; 33) 'self': {unknown}
+[29; 33) 'self': Self
 [107; 198) '{     ...(S); }': ()
 [117; 118) 'x': u32
 [126; 127) 'S': S
@@ -2302,13 +2337,10 @@ fn test() -> u64 {
 }
 fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
-    let func = source_binder::function_from_position(db, pos).unwrap();
+    let file = db.parse(pos.file_id);
-    let body_source_map = func.body_source_map(db);
+    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
-    let inference_result = func.infer(db);
+    let analyzer = SourceAnalyzer::new(db, pos.file_id, expr.syntax(), Some(pos.offset));
-    let (_, syntax) = func.source(db);
+    let ty = analyzer.type_of(db, expr).unwrap();
-    let node = algo::find_node_at_offset::<ast::Expr>(syntax.syntax(), pos.offset).unwrap();
-    let expr = body_source_map.node_expr(node).unwrap();
-    let ty = &inference_result[expr];
    ty.display(db).to_string()
 }
@@ -2324,7 +2356,7 @@ fn infer(content: &str) -> String {
        for (pat, ty) in inference_result.type_of_pat.iter() {
            let syntax_ptr = match body_source_map.pat_syntax(pat) {
-                Some(sp) => sp,
+                Some(sp) => sp.either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr()),
                None => continue,
            };
            types.push((syntax_ptr, ty));
@@ -2350,25 +2382,11 @@ fn infer(content: &str) -> String {
        }
    };
-    for const_def in source_file.syntax().descendants().filter_map(ast::ConstDef::cast) {
+    for node in source_file.syntax().descendants() {
-        let konst = source_binder::const_from_source(&db, file_id, const_def).unwrap();
+        if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
-        let inference_result = konst.infer(&db);
+            let analyzer = SourceAnalyzer::new(&db, file_id, node, None);
-        let body_source_map = konst.body_source_map(&db);
+            infer_def(analyzer.inference_result(), analyzer.body_source_map());
-        infer_def(inference_result, body_source_map)
+        }
-    }
-    for static_def in source_file.syntax().descendants().filter_map(ast::StaticDef::cast) {
-        let static_ = source_binder::static_from_source(&db, file_id, static_def).unwrap();
-        let inference_result = static_.infer(&db);
-        let body_source_map = static_.body_source_map(&db);
-        infer_def(inference_result, body_source_map)
-    }
-    for fn_def in source_file.syntax().descendants().filter_map(ast::FnDef::cast) {
-        let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
-        let inference_result = func.infer(&db);
-        let body_source_map = func.body_source_map(&db);
-        infer_def(inference_result, body_source_map)
    }
    acc.truncate(acc.trim_end().len());
@@ -2403,10 +2421,12 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
        }
    ",
    );
-    let func = source_binder::function_from_position(&db, pos).unwrap();
    {
+        let file = db.parse(pos.file_id);
+        let node =
+            algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            func.infer(&db);
+            SourceAnalyzer::new(&db, pos.file_id, node, None);
        });
        assert!(format!("{:?}", events).contains("infer"))
    }
@@ -2423,8 +2443,11 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
    db.query_mut(ra_db::FileTextQuery).set(pos.file_id, Arc::new(new_text));
    {
+        let file = db.parse(pos.file_id);
+        let node =
+            algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent();
        let events = db.log_executed(|| {
-            func.infer(&db);
+            SourceAnalyzer::new(&db, pos.file_id, node, None);
        });
        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
    }
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
new file mode 100644
index 000000000..f8c3958bd
--- /dev/null
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -0,0 +1,112 @@
+//! Stuff that will probably mostly replaced by Chalk.
+use std::collections::HashMap;
+use crate::db::HirDatabase;
+use super::{ TraitRef, Substs, infer::{ TypeVarId, InferTy}, Ty};
+// Copied (and simplified) from Chalk
+#[derive(Clone, Debug, PartialEq, Eq)]
+/// A (possible) solution for a proposed goal. Usually packaged in a `Result`,
+/// where `Err` represents definite *failure* to prove a goal.
+pub enum Solution {
+    /// The goal indeed holds, and there is a unique value for all existential
+    /// variables.
+    Unique(Substs),
+    /// The goal may be provable in multiple ways, but regardless we may have some guidance
+    /// for type inference.
+    Ambig(Guidance),
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+/// When a goal holds ambiguously (e.g., because there are multiple possible
+/// solutions), we issue a set of *guidance* back to type inference.
+pub enum Guidance {
+    /// The existential variables *must* have the given values if the goal is
+    /// ever to hold, but that alone isn't enough to guarantee the goal will
+    /// actually hold.
+    Definite(Substs),
+    /// There are multiple plausible values for the existentials, but the ones
+    /// here are suggested as the preferred choice heuristically. These should
+    /// be used for inference fallback only.
+    Suggested(Substs),
+    /// There's no useful information to feed back to type inference
+    Unknown,
+}
+/// Something that needs to be proven (by Chalk) during type checking, e.g. that
+/// a certain type implements a certain trait. Proving the Obligation might
+/// result in additional information about inference variables.
+///
+/// This might be handled by Chalk when we integrate it?
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Obligation {
+    /// Prove that a certain type implements a trait (the type is the `Self` type
+    /// parameter to the `TraitRef`).
+    Trait(TraitRef),
+}
+/// Rudimentary check whether an impl exists for a given type and trait; this
+/// will actually be done by chalk.
+pub(crate) fn implements(db: &impl HirDatabase, trait_ref: TraitRef) -> Option<Solution> {
+    // FIXME use all trait impls in the whole crate graph
+    let krate = trait_ref.trait_.module(db).krate(db);
+    let krate = match krate {
+        Some(krate) => krate,
+        None => return None,
+    };
+    let crate_impl_blocks = db.impls_in_crate(krate);
+    let mut impl_blocks = crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_ref.trait_);
+    impl_blocks
+        .find_map(|impl_block| unify_trait_refs(&trait_ref, &impl_block.target_trait_ref(db)?))
+}
+pub(super) fn canonicalize(trait_ref: TraitRef) -> (TraitRef, Vec<TypeVarId>) {
+    let mut canonical = HashMap::new(); // mapping uncanonical -> canonical
+    let mut uncanonical = Vec::new(); // mapping canonical -> uncanonical (which is dense)
+    let mut substs = trait_ref.substs.0.to_vec();
+    for ty in &mut substs {
+        ty.walk_mut(&mut |ty| match ty {
+            Ty::Infer(InferTy::TypeVar(tv)) => {
+                let tv: &mut TypeVarId = tv;
+                *tv = *canonical.entry(*tv).or_insert_with(|| {
+                    let i = uncanonical.len();
+                    uncanonical.push(*tv);
+                    TypeVarId(i as u32)
+                });
+            }
+            _ => {}
+        });
+    }
+    (TraitRef { substs: substs.into(), ..trait_ref }, uncanonical)
+}
+fn unify_trait_refs(tr1: &TraitRef, tr2: &TraitRef) -> Option<Solution> {
+    if tr1.trait_ != tr2.trait_ {
+        return None;
+    }
+    let mut solution_substs = Vec::new();
+    for (t1, t2) in tr1.substs.0.iter().zip(tr2.substs.0.iter()) {
+        // this is very bad / hacky 'unification' logic, just enough to make the simple tests pass
+        match (t1, t2) {
+            (_, Ty::Infer(InferTy::TypeVar(_))) | (_, Ty::Unknown) | (_, Ty::Param { .. }) => {
+                // type variable (or similar) in the impl, we just assume it works
+            }
+            (Ty::Infer(InferTy::TypeVar(v1)), _) => {
+                // type variable in the query and fixed type in the impl, record its value
+                solution_substs.resize_with(v1.0 as usize + 1, || Ty::Unknown);
+                solution_substs[v1.0 as usize] = t2.clone();
+            }
+            _ => {
+                // check that they're equal (actually we'd have to recurse etc.)
+                if t1 != t2 {
+                    return None;
+                }
+            }
+        }
+    }
+    Some(Solution::Unique(solution_substs.into()))
+}