1 files changed, 18 insertions, 95 deletions

diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 6bc6d474c..3f6d2cf35 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -1,20 +1,19 @@
 //! Trait solving using Chalk.
-use std::{panic, sync::Arc};
+use std::sync::Arc;
 
 use chalk_ir::cast::Cast;
-use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
-use ra_db::{impl_intern_key, salsa, CrateId};
+use chalk_solve::Solver;
+use hir_def::{lang_item::LangItemTarget, TraitId};
+use ra_db::CrateId;
 use ra_prof::profile;
-use rustc_hash::FxHashSet;
 
-use crate::{db::HirDatabase, method_resolution::TyFingerprint, DebruijnIndex};
+use crate::{db::HirDatabase, DebruijnIndex, Substs};
 
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
 
 use self::chalk::{from_chalk, Interner, ToChalk};
 
 pub(crate) mod chalk;
-mod builtin;
 
 // This controls the maximum size of types Chalk considers. If we set this too
 // high, we can run into slow edge cases; if we set it too low, Chalk won't
@@ -31,37 +30,10 @@ struct ChalkContext<'a> {
     krate: CrateId,
 }
 
-fn create_chalk_solver() -> chalk_solve::Solver<Interner> {
-    let solver_choice = chalk_solve::SolverChoice::recursive();
-    solver_choice.into_solver()
-}
-
-/// Collects impls for the given trait in the whole dependency tree of `krate`.
-pub(crate) fn impls_for_trait_query(
-    db: &dyn HirDatabase,
-    krate: CrateId,
-    trait_: TraitId,
-    self_ty_fp: Option<TyFingerprint>,
-) -> Arc<[ImplId]> {
-    // FIXME: We could be a lot smarter here - because of the orphan rules and
-    // the fact that the trait and the self type need to be in the dependency
-    // tree of a crate somewhere for an impl to exist, we could skip looking in
-    // a lot of crates completely
-    let mut impls = FxHashSet::default();
-    // We call the query recursively here. On the one hand, this means we can
-    // reuse results from queries for different crates; on the other hand, this
-    // will only ever get called for a few crates near the root of the tree (the
-    // ones the user is editing), so this may actually be a waste of memory. I'm
-    // doing it like this mainly for simplicity for now.
-    for dep in &db.crate_graph()[krate].dependencies {
-        impls.extend(db.impls_for_trait(dep.crate_id, trait_, self_ty_fp).iter());
-    }
-    let crate_impl_defs = db.impls_in_crate(krate);
-    match self_ty_fp {
-        Some(fp) => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait_and_ty(trait_, fp)),
-        None => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait(trait_)),
-    }
-    impls.into_iter().collect()
+fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> {
+    let overflow_depth = 100;
+    let caching_enabled = true;
+    chalk_recursive::RecursiveSolver::new(overflow_depth, caching_enabled)
 }
 
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
@@ -217,15 +189,7 @@ fn solution_from_chalk(
     solution: chalk_solve::Solution<Interner>,
 ) -> Solution {
     let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
-        let value = subst
-            .value
-            .iter(&Interner)
-            .map(|p| match p.ty(&Interner) {
-                Some(ty) => from_chalk(db, ty.clone()),
-                None => unimplemented!(),
-            })
-            .collect();
-        let result = Canonical { value, num_vars: subst.binders.len(&Interner) };
+        let result = from_chalk(db, subst);
         SolutionVariables(result)
     };
     match solution {
@@ -249,7 +213,7 @@ fn solution_from_chalk(
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SolutionVariables(pub Canonical<Vec<Ty>>);
+pub struct SolutionVariables(pub Canonical<Substs>);
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// A (possible) solution for a proposed goal.
@@ -298,53 +262,12 @@ impl FnTrait {
             FnTrait::Fn => "fn",
         }
     }
-}
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ClosureFnTraitImplData {
-    def: DefWithBodyId,
-    expr: ExprId,
-    fn_trait: FnTrait,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct UnsizeToSuperTraitObjectData {
-    trait_: TraitId,
-    super_trait: TraitId,
-}
-
-/// An impl. Usually this comes from an impl block, but some built-in types get
-/// synthetic impls.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Impl {
-    /// A normal impl from an impl block.
-    ImplDef(ImplId),
-    /// Closure types implement the Fn traits synthetically.
-    ClosureFnTraitImpl(ClosureFnTraitImplData),
-    /// [T; n]: Unsize<[T]>
-    UnsizeArray,
-    /// T: Unsize<dyn Trait> where T: Trait
-    UnsizeToTraitObject(TraitId),
-    /// dyn Trait: Unsize<dyn SuperTrait> if Trait: SuperTrait
-    UnsizeToSuperTraitObject(UnsizeToSuperTraitObjectData),
-}
-/// This exists just for Chalk, because our ImplIds are only unique per module.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct GlobalImplId(salsa::InternId);
-impl_intern_key!(GlobalImplId);
-
-/// An associated type value. Usually this comes from a `type` declaration
-/// inside an impl block, but for built-in impls we have to synthesize it.
-/// (We only need this because Chalk wants a unique ID for each of these.)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AssocTyValue {
-    /// A normal assoc type value from an impl block.
-    TypeAlias(TypeAliasId),
-    /// The output type of the Fn trait implementation.
-    ClosureFnTraitImplOutput(ClosureFnTraitImplData),
+    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,
+        }
+    }
 }
-/// This exists just for Chalk, because it needs a unique ID for each associated
-/// type value in an impl (even synthetic ones).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct AssocTyValueId(salsa::InternId);
-impl_intern_key!(AssocTyValueId);