5 files changed, 100 insertions, 36 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 1e7d97f51..a48272981 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -23,6 +23,7 @@ use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
 use rustc_hash::FxHashMap;
 
 use ra_arena::map::ArenaMap;
+use ra_prof::profile;
 use test_utils::tested_by;
 
 use crate::{
@@ -51,7 +52,8 @@ use super::{
 mod unify;
 
 /// The entry point of type inference.
-pub fn infer(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
+pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
+    let _p = profile("infer_query");
     db.check_canceled();
     let body = def.body(db);
     let resolver = def.resolver(db);
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index 8ca7e957d..bc9719725 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -56,7 +56,12 @@ where
                     self.var_stack.pop();
                     result
                 } else {
-                    let free_var = InferTy::TypeVar(self.ctx.var_unification_table.find(inner));
+                    let root = self.ctx.var_unification_table.find(inner);
+                    let free_var = match tv {
+                        InferTy::TypeVar(_) => InferTy::TypeVar(root),
+                        InferTy::IntVar(_) => InferTy::IntVar(root),
+                        InferTy::FloatVar(_) => InferTy::FloatVar(root),
+                    };
                     let position = self.add(free_var);
                     Ty::Bound(position as u32)
                 }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 09d26ce5a..a1a2d0f6b 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -9,17 +9,18 @@ use std::sync::Arc;
 use std::iter;
 
 use crate::{
-    Function, Struct, StructField, Enum, EnumVariant, Path,
-    ModuleDef, TypeAlias,
-    Const, Static,
+    Function, Struct, StructField, Enum, EnumVariant, Path, ModuleDef, TypeAlias, Const, Static,
     HirDatabase,
     type_ref::TypeRef,
     name::KnownName,
     nameres::Namespace,
     resolve::{Resolver, Resolution},
     path::{PathSegment, GenericArg},
-    generics::{GenericParams, HasGenericParams},
-    adt::VariantDef, Trait, generics::{ WherePredicate, GenericDef}
+    generics::{HasGenericParams},
+    adt::VariantDef,
+    Trait,
+    generics::{WherePredicate, GenericDef},
+    ty::AdtDef,
 };
 use super::{Ty, primitive, FnSig, Substs, TypeCtor, TraitRef, GenericPredicate};
 
@@ -120,15 +121,15 @@ impl Ty {
         segment: &PathSegment,
         resolved: TypableDef,
     ) -> Substs {
-        let def_generics = match resolved {
-            TypableDef::Function(func) => func.generic_params(db),
-            TypableDef::Struct(s) => s.generic_params(db),
-            TypableDef::Enum(e) => e.generic_params(db),
-            TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
-            TypableDef::TypeAlias(t) => t.generic_params(db),
-            TypableDef::Const(_) | TypableDef::Static(_) => GenericParams::default().into(),
+        let def_generic: Option<GenericDef> = match resolved {
+            TypableDef::Function(func) => Some(func.into()),
+            TypableDef::Struct(s) => Some(s.into()),
+            TypableDef::Enum(e) => Some(e.into()),
+            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
+            TypableDef::TypeAlias(t) => Some(t.into()),
+            TypableDef::Const(_) | TypableDef::Static(_) => None,
         };
-        substs_from_path_segment(db, resolver, segment, &def_generics, false)
+        substs_from_path_segment(db, resolver, segment, def_generic, false)
     }
 
     /// Collect generic arguments from a path into a `Substs`. See also
@@ -172,10 +173,12 @@ pub(super) fn substs_from_path_segment(
     db: &impl HirDatabase,
     resolver: &Resolver,
     segment: &PathSegment,
-    def_generics: &GenericParams,
+    def_generic: Option<GenericDef>,
     add_self_param: bool,
 ) -> Substs {
     let mut substs = Vec::new();
+    let def_generics = def_generic.map(|def| def.generic_params(db)).unwrap_or_default();
+
     let parent_param_count = def_generics.count_parent_params();
     substs.extend(iter::repeat(Ty::Unknown).take(parent_param_count));
     if add_self_param {
@@ -199,12 +202,24 @@ pub(super) fn substs_from_path_segment(
         }
     }
     // 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());
+
+    // handle defaults
+    if let Some(def_generic) = def_generic {
+        let default_substs = db.generic_defaults(def_generic);
+        assert_eq!(substs.len(), default_substs.len());
+
+        for (i, default_ty) in default_substs.iter().enumerate() {
+            if substs[i] == Ty::Unknown {
+                substs[i] = default_ty.clone();
+            }
+        }
+    }
+
     Substs(substs.into())
 }
 
@@ -249,7 +264,7 @@ impl TraitRef {
         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)
+        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), true)
     }
 
     pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
@@ -274,9 +289,9 @@ impl TraitRef {
 pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty {
     match (def, ns) {
         (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f),
-        (TypableDef::Struct(s), Namespace::Types) => type_for_struct(db, s),
+        (TypableDef::Struct(s), Namespace::Types) => type_for_adt(db, s),
         (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s),
-        (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e),
+        (TypableDef::Enum(e), Namespace::Types) => type_for_adt(db, e),
         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
         (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
         (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
@@ -331,6 +346,22 @@ pub(crate) fn generic_predicates(
     predicates.into()
 }
 
+/// Resolve the default type params from generics
+pub(crate) fn generic_defaults(db: &impl HirDatabase, def: GenericDef) -> Substs {
+    let resolver = def.resolver(db);
+    let generic_params = def.generic_params(db);
+
+    let defaults = generic_params
+        .params_including_parent()
+        .into_iter()
+        .map(|p| {
+            p.default.as_ref().map_or(Ty::Unknown, |path| Ty::from_hir_path(db, &resolver, path))
+        })
+        .collect::<Vec<_>>();
+
+    Substs(defaults.into())
+}
+
 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
     let signature = def.signature(db);
     let resolver = def.resolver(db);
@@ -375,7 +406,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
         .iter()
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
-    let ret = type_for_struct(db, def);
+    let ret = type_for_adt(db, def);
     FnSig::from_params_and_return(params, ret)
 }
 
@@ -383,7 +414,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
 fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
     let var_data = def.variant_data(db);
     if var_data.fields().is_none() {
-        return type_for_struct(db, def); // Unit struct
+        return type_for_adt(db, def); // Unit struct
     }
     let generics = def.generic_params(db);
     let substs = Substs::identity(&generics);
@@ -403,7 +434,7 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant)
         .collect::<Vec<_>>();
     let generics = def.parent_enum(db).generic_params(db);
     let substs = Substs::identity(&generics);
-    let ret = type_for_enum(db, def.parent_enum(db)).subst(&substs);
+    let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs);
     FnSig::from_params_and_return(params, ret)
 }
 
@@ -411,21 +442,16 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant)
 fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
     let var_data = def.variant_data(db);
     if var_data.fields().is_none() {
-        return type_for_enum(db, def.parent_enum(db)); // Unit variant
+        return type_for_adt(db, def.parent_enum(db)); // Unit variant
     }
     let generics = def.parent_enum(db).generic_params(db);
     let substs = Substs::identity(&generics);
     Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
 
-fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
-    let generics = s.generic_params(db);
-    Ty::apply(TypeCtor::Adt(s.into()), Substs::identity(&generics))
-}
-
-fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
-    let generics = s.generic_params(db);
-    Ty::apply(TypeCtor::Adt(s.into()), Substs::identity(&generics))
+fn type_for_adt(db: &impl HirDatabase, adt: impl Into<AdtDef> + HasGenericParams) -> Ty {
+    let generics = adt.generic_params(db);
+    Ty::apply(TypeCtor::Adt(adt.into()), Substs::identity(&generics))
 }
 
 fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index f8364203d..cd24faba5 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1449,6 +1449,35 @@ fn test() {
 }
 
 #[test]
+fn infer_associated_method_generics_with_default_param() {
+    assert_snapshot_matches!(
+        infer(r#"
+struct Gen<T=u32> {
+    val: T
+}
+
+impl<T> Gen<T> {
+    pub fn make() -> Gen<T> {
+        loop { }
+    }
+}
+
+fn test() {
+    let a = Gen::make();
+}
+"#),
+        @r###"
+[80; 104) '{     ...     }': !
+[90; 98) 'loop { }': !
+[95; 98) '{ }': ()
+[118; 146) '{     ...e(); }': ()
+[128; 129) 'a': Gen<u32>
+[132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
+[132; 143) 'Gen::make()': Gen<u32>"###
+    );
+}
+
+#[test]
 fn infer_associated_method_generics_without_args() {
     assert_snapshot_matches!(
         infer(r#"
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index 7de04c044..e6c78c0d4 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -4,6 +4,7 @@ use std::sync::{Arc, Mutex};
 use rustc_hash::FxHashSet;
 use log::debug;
 use chalk_ir::cast::Cast;
+use ra_prof::profile;
 
 use crate::{Crate, Trait, db::HirDatabase, ImplBlock};
 use super::{TraitRef, Ty, Canonical};
@@ -25,7 +26,7 @@ struct ChalkContext<'a, DB> {
     krate: Crate,
 }
 
-pub(crate) fn solver(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>> {
+pub(crate) fn solver_query(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>> {
     // krate parameter is just so we cache a unique solver per crate
     let solver_choice = chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE };
     debug!("Creating new solver for crate {:?}", _krate);
@@ -33,7 +34,7 @@ pub(crate) fn solver(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>
 }
 
 /// Collects impls for the given trait in the whole dependency tree of `krate`.
-pub(crate) fn impls_for_trait(
+pub(crate) fn impls_for_trait_query(
     db: &impl HirDatabase,
     krate: Crate,
     trait_: Trait,
@@ -60,7 +61,7 @@ fn solve(
     let context = ChalkContext { db, krate };
     let solver = db.solver(krate);
     debug!("solve goal: {:?}", goal);
-    let solution = solver.lock().unwrap().solve(&context, goal);
+    let solution = solver.lock().unwrap().solve_with_fuel(&context, goal, Some(1000));
     debug!("solve({:?}) => {:?}", goal, solution);
     solution
 }
@@ -76,11 +77,12 @@ pub enum Obligation {
 }
 
 /// Check using Chalk whether trait is implemented for given parameters including `Self` type.
-pub(crate) fn implements(
+pub(crate) fn implements_query(
     db: &impl HirDatabase,
     krate: Crate,
     trait_ref: Canonical<TraitRef>,
 ) -> Option<Solution> {
+    let _p = profile("implements_query");
     let goal: chalk_ir::Goal = trait_ref.value.to_chalk(db).cast();
     debug!("goal: {:?}", goal);
     let env = chalk_ir::Environment::new();