5 files changed, 35 insertions, 37 deletions

diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 95ac3c713..959b1e212 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -7,13 +7,11 @@
 use hir_def::{lang_item::LangItemTarget, type_ref::Mutability};
 use test_utils::tested_by;
 
-use crate::{
-    autoderef, db::HirDatabase, traits::Solution, Obligation, Substs, TraitRef, Ty, TypeCtor,
-};
+use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty, TypeCtor};
 
 use super::{unify::TypeVarValue, InEnvironment, InferTy, InferenceContext};
 
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+impl<'a> InferenceContext<'a> {
     /// Unify two types, but may coerce the first one to the second one
     /// using "implicit coercion rules" if needed.
     pub(super) fn coerce(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
@@ -126,7 +124,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             _ => return None,
         };
 
-        let generic_params = crate::utils::generics(self.db, coerce_unsized_trait.into());
+        let generic_params = crate::utils::generics(self.db.upcast(), coerce_unsized_trait.into());
         if generic_params.len() != 2 {
             // The CoerceUnsized trait should have two generic params: Self and T.
             return None;
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index e89cc7298..1fdb235a0 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -14,9 +14,7 @@ use hir_expand::name::Name;
 use ra_syntax::ast::RangeOp;
 
 use crate::{
-    autoderef,
-    db::HirDatabase,
-    method_resolution, op,
+    autoderef, method_resolution, op,
     traits::InEnvironment,
     utils::{generics, variant_data, Generics},
     ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef,
@@ -25,7 +23,7 @@ use crate::{
 
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
 
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+impl<'a> InferenceContext<'a> {
     pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
         let ty = self.infer_expr_inner(tgt_expr, expected);
         let could_unify = self.unify(&ty, &expected.ty);
@@ -184,7 +182,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::Path(p) => {
                 // FIXME this could be more efficient...
-                let resolver = resolver_for_expr(self.db, self.owner, tgt_expr);
+                let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
                 self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
             }
             Expr::Continue => Ty::simple(TypeCtor::Never),
@@ -214,7 +212,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 let substs = ty.substs().unwrap_or_else(Substs::empty);
                 let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
-                let variant_data = def_id.map(|it| variant_data(self.db, it));
+                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
                 for (field_idx, field) in fields.iter().enumerate() {
                     let field_def =
                         variant_data.as_ref().and_then(|it| match it.field(&field.name) {
@@ -579,7 +577,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         let receiver_ty = self.infer_expr(receiver, &Expectation::none());
         let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
 
-        let traits_in_scope = self.resolver.traits_in_scope(self.db);
+        let traits_in_scope = self.resolver.traits_in_scope(self.db.upcast());
 
         let resolved = self.resolver.krate().and_then(|krate| {
             method_resolution::lookup_method(
@@ -595,7 +593,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Some((ty, func)) => {
                 let ty = canonicalized_receiver.decanonicalize_ty(ty);
                 self.write_method_resolution(tgt_expr, func);
-                (ty, self.db.value_ty(func.into()), Some(generics(self.db, func.into())))
+                (ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into())))
             }
             None => (receiver_ty, Binders::new(0, Ty::Unknown), None),
         };
@@ -703,10 +701,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 // add obligation for trait implementation, if this is a trait method
                 match def {
                     CallableDef::FunctionId(f) => {
-                        if let AssocContainerId::TraitId(trait_) = f.lookup(self.db).container {
+                        if let AssocContainerId::TraitId(trait_) =
+                            f.lookup(self.db.upcast()).container
+                        {
                             // construct a TraitDef
-                            let substs =
-                                a_ty.parameters.prefix(generics(self.db, trait_.into()).len());
+                            let substs = a_ty
+                                .parameters
+                                .prefix(generics(self.db.upcast(), trait_.into()).len());
                             self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
                         }
                     }
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 7a84e47f8..baed6225b 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -12,9 +12,9 @@ use hir_expand::name::Name;
 use test_utils::tested_by;
 
 use super::{BindingMode, InferenceContext};
-use crate::{db::HirDatabase, utils::variant_data, Substs, Ty, TypeCtor};
+use crate::{utils::variant_data, Substs, Ty, TypeCtor};
 
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+impl<'a> InferenceContext<'a> {
     fn infer_tuple_struct_pat(
         &mut self,
         path: Option<&Path>,
@@ -23,7 +23,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         default_bm: BindingMode,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
-        let var_data = def.map(|it| variant_data(self.db, it));
+        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
         self.unify(&ty, expected);
 
         let substs = ty.substs().unwrap_or_else(Substs::empty);
@@ -51,7 +51,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         id: PatId,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
-        let var_data = def.map(|it| variant_data(self.db, it));
+        let var_data = def.map(|it| variant_data(self.db.upcast(), it));
         if let Some(variant) = def {
             self.write_variant_resolution(id.into(), variant);
         }
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index c733b9e1d..318652c61 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -9,11 +9,11 @@ use hir_def::{
 };
 use hir_expand::name::Name;
 
-use crate::{db::HirDatabase, method_resolution, Substs, Ty, ValueTyDefId};
+use crate::{method_resolution, Substs, Ty, ValueTyDefId};
 
 use super::{ExprOrPatId, InferenceContext, TraitRef};
 
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
+impl<'a> InferenceContext<'a> {
     pub(super) fn infer_path(
         &mut self,
         resolver: &Resolver,
@@ -47,7 +47,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 id,
             )?
         } else {
-            let value_or_partial = resolver.resolve_path_in_value_ns(self.db, path.mod_path())?;
+            let value_or_partial =
+                resolver.resolve_path_in_value_ns(self.db.upcast(), path.mod_path())?;
 
             match value_or_partial {
                 ResolveValueResult::ValueNs(it) => (it, None),
@@ -192,7 +193,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
         let canonical_ty = self.canonicalizer().canonicalize_ty(ty.clone());
         let krate = self.resolver.krate()?;
-        let traits_in_scope = self.resolver.traits_in_scope(self.db);
+        let traits_in_scope = self.resolver.traits_in_scope(self.db.upcast());
 
         method_resolution::iterate_method_candidates(
             &canonical_ty.value,
@@ -205,9 +206,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             move |_ty, item| {
                 let (def, container) = match item {
                     AssocItemId::FunctionId(f) => {
-                        (ValueNs::FunctionId(f), f.lookup(self.db).container)
+                        (ValueNs::FunctionId(f), f.lookup(self.db.upcast()).container)
+                    }
+                    AssocItemId::ConstId(c) => {
+                        (ValueNs::ConstId(c), c.lookup(self.db.upcast()).container)
                     }
-                    AssocItemId::ConstId(c) => (ValueNs::ConstId(c), c.lookup(self.db).container),
                     AssocItemId::TypeAliasId(_) => unreachable!(),
                 };
                 let substs = match container {
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index 82b85d570..0bf8fbd63 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -7,10 +7,10 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use test_utils::tested_by;
 
 use super::{InferenceContext, Obligation};
-use crate::{db::HirDatabase, Canonical, InEnvironment, InferTy, Substs, Ty, TypeCtor, TypeWalk};
+use crate::{Canonical, InEnvironment, InferTy, Substs, Ty, TypeCtor, TypeWalk};
 
-impl<'a, D: HirDatabase> InferenceContext<'a, D> {
-    pub(super) fn canonicalizer<'b>(&'b mut self) -> Canonicalizer<'a, 'b, D>
+impl<'a> InferenceContext<'a> {
+    pub(super) fn canonicalizer<'b>(&'b mut self) -> Canonicalizer<'a, 'b>
     where
         'a: 'b,
     {
@@ -18,11 +18,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 }
 
-pub(super) struct Canonicalizer<'a, 'b, D: HirDatabase>
+pub(super) struct Canonicalizer<'a, 'b>
 where
     'a: 'b,
 {
-    ctx: &'b mut InferenceContext<'a, D>,
+    ctx: &'b mut InferenceContext<'a>,
     free_vars: Vec<InferTy>,
     /// A stack of type variables that is used to detect recursive types (which
     /// are an error, but we need to protect against them to avoid stack
@@ -35,7 +35,7 @@ pub(super) struct Canonicalized<T> {
     free_vars: Vec<InferTy>,
 }
 
-impl<'a, 'b, D: HirDatabase> Canonicalizer<'a, 'b, D>
+impl<'a, 'b> Canonicalizer<'a, 'b>
 where
     'a: 'b,
 {
@@ -123,11 +123,7 @@ impl<T> Canonicalized<T> {
         ty
     }
 
-    pub fn apply_solution(
-        &self,
-        ctx: &mut InferenceContext<'_, impl HirDatabase>,
-        solution: Canonical<Vec<Ty>>,
-    ) {
+    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Vec<Ty>>) {
         // the solution may contain new variables, which we need to convert to new inference vars
         let new_vars = Substs((0..solution.num_vars).map(|_| ctx.table.new_type_var()).collect());
         for (i, ty) in solution.value.into_iter().enumerate() {