10 files changed, 55 insertions, 81 deletions

diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index de2c2dbec..833956ce8 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -21,9 +21,9 @@ tt = { path = "../ra_tt", package = "ra_tt" }
 test_utils = { path = "../test_utils" }
 ra_prof = { path = "../ra_prof" }
 
-chalk-solve = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
-chalk-rust-ir = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
-chalk-ir = { git = "https://github.com/flodiebold/chalk.git", branch = "fuel" }
+chalk-solve = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-ir = { git = "https://github.com/rust-lang/chalk.git" }
 lalrpop-intern = "0.15.1"
 
 [dev-dependencies]
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index b0c027631..040c782e6 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -189,9 +189,9 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
     /// because Chalk does its own internal caching, the solver is wrapped in a
     /// Mutex and the query is marked volatile, to make sure the cached state is
     /// thrown away when input facts change.
-    #[salsa::invoke(crate::ty::traits::solver_query)]
+    #[salsa::invoke(crate::ty::traits::trait_solver_query)]
     #[salsa::volatile]
-    fn solver(&self, krate: Crate) -> Arc<Mutex<crate::ty::traits::Solver>>;
+    fn trait_solver(&self, krate: Crate) -> Arc<Mutex<crate::ty::traits::Solver>>;
 
     #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
     fn associated_ty_data(&self, id: chalk_ir::TypeId) -> Arc<chalk_rust_ir::AssociatedTyDatum>;
@@ -213,8 +213,8 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
     #[salsa::invoke(crate::ty::traits::chalk::impl_datum_query)]
     fn impl_datum(&self, krate: Crate, impl_id: chalk_ir::ImplId) -> Arc<chalk_rust_ir::ImplDatum>;
 
-    #[salsa::invoke(crate::ty::traits::solve_query)]
-    fn solve(
+    #[salsa::invoke(crate::ty::traits::trait_solve_query)]
+    fn trait_solve(
         &self,
         krate: Crate,
         goal: crate::ty::Canonical<crate::ty::InEnvironment<crate::ty::Obligation>>,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 9accffcbc..4cf714f5d 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -26,7 +26,7 @@ pub(crate) use lower::{
     callable_item_sig, generic_defaults_query, generic_predicates_query, type_for_def,
     type_for_field, TypableDef,
 };
-pub(crate) use traits::{Environment, InEnvironment, Obligation, ProjectionPredicate};
+pub(crate) use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 
 /// 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
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index c26513871..2535d4ae7 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -68,7 +68,7 @@ fn deref_by_trait(
 
     let canonical = super::Canonical { num_vars: 1 + ty.num_vars, value: in_env };
 
-    let solution = db.solve(krate, canonical)?;
+    let solution = db.trait_solve(krate, canonical)?;
 
     match &solution {
         Solution::Unique(vars) => {
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 5ad4f73ec..0e030576d 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -29,8 +29,8 @@ use test_utils::tested_by;
 use super::{
     autoderef, lower, method_resolution, op, primitive,
     traits::{Guidance, Obligation, ProjectionPredicate, Solution},
-    ApplicationTy, CallableDef, Environment, InEnvironment, ProjectionTy, Substs, TraitRef, Ty,
-    TypableDef, TypeCtor,
+    ApplicationTy, CallableDef, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef,
+    Ty, TypableDef, TypeCtor,
 };
 use crate::{
     adt::VariantDef,
@@ -107,7 +107,7 @@ impl Default for BindingMode {
 }
 
 /// The result of type inference: A mapping from expressions and patterns to types.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
     /// For each method call expr, records the function it resolves to.
     method_resolutions: FxHashMap<ExprId, Function>,
@@ -170,15 +170,9 @@ struct InferenceContext<'a, D: HirDatabase> {
     body: Arc<Body>,
     resolver: Resolver,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
-    trait_env: Arc<Environment>,
+    trait_env: Arc<TraitEnvironment>,
     obligations: Vec<Obligation>,
-    method_resolutions: FxHashMap<ExprId, Function>,
-    field_resolutions: FxHashMap<ExprId, StructField>,
-    variant_resolutions: FxHashMap<ExprId, VariantDef>,
-    assoc_resolutions: FxHashMap<ExprOrPatId, ImplItem>,
-    type_of_expr: ArenaMap<ExprId, Ty>,
-    type_of_pat: ArenaMap<PatId, Ty>,
-    diagnostics: Vec<InferenceDiagnostic>,
+    result: InferenceResult,
     /// The return type of the function being inferred.
     return_ty: Ty,
 }
@@ -186,13 +180,7 @@ struct InferenceContext<'a, D: HirDatabase> {
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     fn new(db: &'a D, body: Arc<Body>, resolver: Resolver) -> Self {
         InferenceContext {
-            method_resolutions: FxHashMap::default(),
-            field_resolutions: FxHashMap::default(),
-            variant_resolutions: FxHashMap::default(),
-            assoc_resolutions: FxHashMap::default(),
-            type_of_expr: ArenaMap::default(),
-            type_of_pat: ArenaMap::default(),
-            diagnostics: Vec::default(),
+            result: InferenceResult::default(),
             var_unification_table: InPlaceUnificationTable::new(),
             obligations: Vec::default(),
             return_ty: Ty::Unknown, // set in collect_fn_signature
@@ -205,50 +193,45 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
     fn resolve_all(mut self) -> InferenceResult {
         // FIXME resolve obligations as well (use Guidance if necessary)
+        let mut result = mem::replace(&mut self.result, InferenceResult::default());
         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() {
+        for ty in result.type_of_expr.values_mut() {
             let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
             *ty = resolved;
         }
-        let mut pat_types = mem::replace(&mut self.type_of_pat, ArenaMap::default());
-        for ty in pat_types.values_mut() {
+        for ty in result.type_of_pat.values_mut() {
             let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
             *ty = resolved;
         }
-        InferenceResult {
-            method_resolutions: self.method_resolutions,
-            field_resolutions: self.field_resolutions,
-            variant_resolutions: self.variant_resolutions,
-            assoc_resolutions: self.assoc_resolutions,
-            type_of_expr: expr_types,
-            type_of_pat: pat_types,
-            diagnostics: self.diagnostics,
-        }
+        result
     }
 
     fn write_expr_ty(&mut self, expr: ExprId, ty: Ty) {
-        self.type_of_expr.insert(expr, ty);
+        self.result.type_of_expr.insert(expr, ty);
     }
 
     fn write_method_resolution(&mut self, expr: ExprId, func: Function) {
-        self.method_resolutions.insert(expr, func);
+        self.result.method_resolutions.insert(expr, func);
     }
 
     fn write_field_resolution(&mut self, expr: ExprId, field: StructField) {
-        self.field_resolutions.insert(expr, field);
+        self.result.field_resolutions.insert(expr, field);
     }
 
     fn write_variant_resolution(&mut self, expr: ExprId, variant: VariantDef) {
-        self.variant_resolutions.insert(expr, variant);
+        self.result.variant_resolutions.insert(expr, variant);
     }
 
     fn write_assoc_resolution(&mut self, id: ExprOrPatId, item: ImplItem) {
-        self.assoc_resolutions.insert(id, item);
+        self.result.assoc_resolutions.insert(id, item);
     }
 
     fn write_pat_ty(&mut self, pat: PatId, ty: Ty) {
-        self.type_of_pat.insert(pat, ty);
+        self.result.type_of_pat.insert(pat, ty);
+    }
+
+    fn push_diagnostic(&mut self, diagnostic: InferenceDiagnostic) {
+        self.result.diagnostics.push(diagnostic);
     }
 
     fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
@@ -345,7 +328,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             let in_env = InEnvironment::new(self.trait_env.clone(), obligation.clone());
             let canonicalized = self.canonicalizer().canonicalize_obligation(in_env);
             let solution =
-                self.db.solve(self.resolver.krate().unwrap(), canonicalized.value.clone());
+                self.db.trait_solve(self.resolver.krate().unwrap(), canonicalized.value.clone());
 
             match solution {
                 Some(Solution::Unique(substs)) => {
@@ -565,7 +548,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 Some(ty)
             }
             Resolution::LocalBinding(pat) => {
-                let ty = self.type_of_pat.get(pat)?.clone();
+                let ty = self.result.type_of_pat.get(pat)?.clone();
                 let ty = self.resolve_ty_as_possible(&mut vec![], ty);
                 Some(ty)
             }
@@ -1090,7 +1073,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         .and_then(|it| match it.field(self.db, &field.name) {
                             Some(field) => Some(field),
                             None => {
-                                self.diagnostics.push(InferenceDiagnostic::NoSuchField {
+                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
                                     expr: tgt_expr,
                                     field: field_idx,
                                 });
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index ca47d6e96..894ba0695 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -317,7 +317,10 @@ pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
     Ty::from_hir(db, &resolver, type_ref)
 }
 
-pub(crate) fn trait_env(db: &impl HirDatabase, resolver: &Resolver) -> Arc<super::Environment> {
+pub(crate) fn trait_env(
+    db: &impl HirDatabase,
+    resolver: &Resolver,
+) -> Arc<super::TraitEnvironment> {
     let predicates = resolver
         .where_predicates_in_scope()
         .map(|pred| {
@@ -326,7 +329,7 @@ pub(crate) fn trait_env(db: &impl HirDatabase, resolver: &Resolver) -> Arc<super
         })
         .collect::<Vec<_>>();
 
-    Arc::new(super::Environment { predicates })
+    Arc::new(super::TraitEnvironment { predicates })
 }
 
 /// Resolve the where clause(s) of an item with generics.
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 353820436..d421bf9ef 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use arrayvec::ArrayVec;
 use rustc_hash::FxHashMap;
 
-use super::{autoderef, lower, Canonical, Environment, InEnvironment, TraitRef};
+use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
 use crate::{
     generics::HasGenericParams,
     impl_block::{ImplBlock, ImplId, ImplItem},
@@ -214,7 +214,7 @@ fn iterate_trait_method_candidates<T>(
                 if name.map_or(true, |name| data.name() == name) && data.has_self_param() {
                     if !known_implemented {
                         let goal = generic_implements_goal(db, env.clone(), t, ty.clone());
-                        if db.solve(krate, goal).is_none() {
+                        if db.trait_solve(krate, goal).is_none() {
                             continue 'traits;
                         }
                     }
@@ -283,7 +283,7 @@ impl Ty {
 /// for all other parameters, to query Chalk with it.
 fn generic_implements_goal(
     db: &impl HirDatabase,
-    env: Arc<Environment>,
+    env: Arc<TraitEnvironment>,
     trait_: Trait,
     self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index 2817c9e71..0769e6e17 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -27,7 +27,7 @@ struct ChalkContext<'a, DB> {
     krate: Crate,
 }
 
-pub(crate) fn solver_query(_db: &impl HirDatabase, _krate: Crate) -> Arc<Mutex<Solver>> {
+pub(crate) fn trait_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);
@@ -60,9 +60,9 @@ fn solve(
     goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal>>,
 ) -> Option<chalk_solve::Solution> {
     let context = ChalkContext { db, krate };
-    let solver = db.solver(krate);
+    let solver = db.trait_solver(krate);
     debug!("solve goal: {:?}", goal);
-    let solution = solver.lock().solve_with_fuel(&context, goal, Some(1000));
+    let solution = solver.lock().solve(&context, goal);
     debug!("solve({:?}) => {:?}", goal, solution);
     solution
 }
@@ -73,19 +73,19 @@ fn solve(
 /// ```
 /// we assume that `T: Default`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Environment {
+pub struct TraitEnvironment {
     pub predicates: Vec<GenericPredicate>,
 }
 
 /// Something (usually a goal), along with an environment.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct InEnvironment<T> {
-    pub environment: Arc<Environment>,
+    pub environment: Arc<TraitEnvironment>,
     pub value: T,
 }
 
 impl<T> InEnvironment<T> {
-    pub fn new(environment: Arc<Environment>, value: T) -> InEnvironment<T> {
+    pub fn new(environment: Arc<TraitEnvironment>, value: T) -> InEnvironment<T> {
         InEnvironment { environment, value }
     }
 }
@@ -117,12 +117,12 @@ pub struct ProjectionPredicate {
 }
 
 /// Solve a trait goal using Chalk.
-pub(crate) fn solve_query(
+pub(crate) fn trait_solve_query(
     db: &impl HirDatabase,
     krate: Crate,
     trait_ref: Canonical<InEnvironment<Obligation>>,
 ) -> Option<Solution> {
-    let _p = profile("solve_query");
+    let _p = profile("trait_solve_query");
     let canonical = trait_ref.to_chalk(db).cast();
     // We currently don't deal with universes (I think / hope they're not yet
     // relevant for our use cases?)
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 2df4dd13f..9e7ae0724 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -266,7 +266,7 @@ where
     }
 }
 
-impl ToChalk for Arc<super::Environment> {
+impl ToChalk for Arc<super::TraitEnvironment> {
     type Chalk = Arc<chalk_ir::Environment>;
 
     fn to_chalk(self, db: &impl HirDatabase) -> Arc<chalk_ir::Environment> {
@@ -276,11 +276,6 @@ impl ToChalk for Arc<super::Environment> {
                 // for env, we just ignore errors
                 continue;
             }
-            if let GenericPredicate::Implemented(trait_ref) = pred {
-                if blacklisted_trait(db, trait_ref.trait_) {
-                    continue;
-                }
-            }
             clauses.push(pred.clone().to_chalk(db).cast());
         }
         chalk_ir::Environment::new().add_clauses(clauses)
@@ -289,7 +284,7 @@ impl ToChalk for Arc<super::Environment> {
     fn from_chalk(
         _db: &impl HirDatabase,
         _env: Arc<chalk_ir::Environment>,
-    ) -> Arc<super::Environment> {
+    ) -> Arc<super::TraitEnvironment> {
         unimplemented!()
     }
 }
@@ -322,10 +317,10 @@ fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T> {
     }
 }
 
-fn blacklisted_trait(db: &impl HirDatabase, trait_: Trait) -> bool {
+fn is_non_enumerable_trait(db: &impl HirDatabase, trait_: Trait) -> bool {
     let name = trait_.name(db).unwrap_or_else(crate::Name::missing).to_string();
     match &*name {
-        "Send" | "Sync" | "Sized" | "Fn" | "FnMut" | "FnOnce" => true,
+        "Sized" => true,
         _ => false,
     }
 }
@@ -343,11 +338,6 @@ fn convert_where_clauses(
             // anyway), otherwise Chalk can easily get into slow situations
             return vec![pred.clone().subst(substs).to_chalk(db)];
         }
-        if let GenericPredicate::Implemented(trait_ref) = pred {
-            if blacklisted_trait(db, trait_ref.trait_) {
-                continue;
-            }
-        }
         result.push(pred.clone().subst(substs).to_chalk(db));
     }
     result
@@ -375,10 +365,6 @@ where
             return Vec::new();
         }
         let trait_: Trait = from_chalk(self.db, trait_id);
-        let blacklisted = blacklisted_trait(self.db, trait_);
-        if blacklisted {
-            return Vec::new();
-        }
         let result: Vec<_> = self
             .db
             .impls_for_trait(self.krate, trait_)
@@ -460,6 +446,7 @@ pub(crate) fn trait_datum_query(
             associated_ty_ids: Vec::new(),
             where_clauses: Vec::new(),
             flags: chalk_rust_ir::TraitFlags {
+                non_enumerable: false,
                 auto: false,
                 marker: false,
                 upstream: true,
@@ -476,6 +463,7 @@ pub(crate) fn trait_datum_query(
     let flags = chalk_rust_ir::TraitFlags {
         auto: trait_.is_auto(db),
         upstream: trait_.module(db).krate(db) != Some(krate),
+        non_enumerable: is_non_enumerable_trait(db, trait_),
         // FIXME set these flags correctly
         marker: false,
         fundamental: false,
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 1ba818197..147d2b21d 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -302,7 +302,7 @@ impl RootDatabase {
             hir::db::TraitDatumQuery
             hir::db::StructDatumQuery
             hir::db::ImplDatumQuery
-            hir::db::SolveQuery
+            hir::db::TraitSolveQuery
         ];
         acc.sort_by_key(|it| std::cmp::Reverse(it.1));
         acc