Merge branch 'master' of https://github.com/rust-analyzer/rust-analyzer into feature/themes

3 files changed, 36 insertions, 29 deletions

diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index 6ea135126..0772b9df5 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -4,19 +4,19 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
+use hir_def::resolver::Resolver;
 use rustc_hash::FxHashMap;
-
 use test_utils::tested_by;
 
-use super::{InferTy, InferenceContext, TypeVarValue};
 use crate::{
     db::HirDatabase,
     lang_item::LangItemTarget,
-    resolve::Resolver,
     ty::{autoderef, Substs, Ty, TypeCtor, TypeWalk},
     Adt, Mutability,
 };
 
+use super::{InferTy, InferenceContext, TypeVarValue};
+
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// Unify two types, but may coerce the first one to the second one
     /// using "implicit coercion rules" if needed.
@@ -49,8 +49,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         resolver: &Resolver,
     ) -> FxHashMap<(TypeCtor, TypeCtor), usize> {
         let krate = resolver.krate().unwrap();
-        let impls = match db.lang_item(krate, "coerce_unsized".into()) {
-            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate, trait_),
+        let impls = match db.lang_item(krate.into(), "coerce_unsized".into()) {
+            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate.into(), trait_),
             _ => return FxHashMap::default(),
         };
 
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 5e68a1678..20a7e9352 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -5,15 +5,15 @@ use std::sync::Arc;
 
 use hir_def::{
     builtin_type::Signedness,
+    generics::GenericParams,
     path::{GenericArg, GenericArgs},
+    resolver::resolver_for_expr,
 };
 use hir_expand::name;
 
-use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
 use crate::{
     db::HirDatabase,
-    expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
-    generics::{GenericParams, HasGenericParams},
+    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     ty::{
         autoderef, method_resolution, op, CallableDef, InferTy, IntTy, Mutability, Namespace,
         Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
@@ -22,6 +22,8 @@ use crate::{
     Adt, Name,
 };
 
+use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
+
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
         let ty = self.infer_expr_inner(tgt_expr, expected);
@@ -186,7 +188,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::Path(p) => {
                 // FIXME this could be more efficient...
-                let resolver = expr::resolver_for_expr(self.db, self.owner, tgt_expr);
+                let resolver = resolver_for_expr(self.db, self.owner.into(), tgt_expr);
                 self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
             }
             Expr::Continue => Ty::simple(TypeCtor::Never),
@@ -532,7 +534,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 (
                     ty,
                     self.db.type_for_def(func.into(), Namespace::Values),
-                    Some(func.generic_params(self.db)),
+                    Some(self.db.generic_params(func.id.into())),
                 )
             }
             None => (receiver_ty, Ty::Unknown, None),
@@ -643,7 +645,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         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.db
+                                    .generic_params(trait_.id.into())
+                                    .count_params_including_parent(),
                             );
                             self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
                         }
diff --git a/crates/ra_hir/src/ty/infer/path.rs b/crates/ra_hir/src/ty/infer/path.rs
index 31ca675aa..ee54d8217 100644
--- a/crates/ra_hir/src/ty/infer/path.rs
+++ b/crates/ra_hir/src/ty/infer/path.rs
@@ -1,16 +1,18 @@
 //! Path expression resolution.
 
-use hir_def::path::PathSegment;
+use hir_def::{
+    path::PathSegment,
+    resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs},
+};
 
-use super::{ExprOrPatId, InferenceContext, TraitRef};
 use crate::{
     db::HirDatabase,
-    generics::HasGenericParams,
-    resolve::{ResolveValueResult, Resolver, TypeNs, ValueNs},
     ty::{method_resolution, Namespace, Substs, Ty, TypableDef, TypeWalk},
-    AssocItem, Container, Name, Path,
+    AssocItem, Container, Function, Name, Path,
 };
 
+use super::{ExprOrPatId, InferenceContext, TraitRef};
+
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     pub(super) fn infer_path(
         &mut self,
@@ -60,11 +62,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let ty = self.resolve_ty_as_possible(&mut vec![], ty);
                 return Some(ty);
             }
-            ValueNs::Function(it) => it.into(),
-            ValueNs::Const(it) => it.into(),
-            ValueNs::Static(it) => it.into(),
-            ValueNs::Struct(it) => it.into(),
-            ValueNs::EnumVariant(it) => it.into(),
+            ValueNs::FunctionId(it) => it.into(),
+            ValueNs::ConstId(it) => it.into(),
+            ValueNs::StaticId(it) => it.into(),
+            ValueNs::StructId(it) => it.into(),
+            ValueNs::EnumVariantId(it) => it.into(),
         };
 
         let mut ty = self.db.type_for_def(typable, Namespace::Values);
@@ -94,13 +96,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         let is_before_last = remaining_segments.len() == 1;
 
         match (def, is_before_last) {
-            (TypeNs::Trait(trait_), true) => {
+            (TypeNs::TraitId(trait_), true) => {
                 let segment =
                     remaining_segments.last().expect("there should be at least one segment here");
                 let trait_ref = TraitRef::from_resolved_path(
                     self.db,
                     &self.resolver,
-                    trait_,
+                    trait_.into(),
                     resolved_segment,
                     None,
                 );
@@ -160,8 +162,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             AssocItem::TypeAlias(_) => None,
         })?;
         let def = match item {
-            AssocItem::Function(f) => ValueNs::Function(f),
-            AssocItem::Const(c) => ValueNs::Const(c),
+            AssocItem::Function(f) => ValueNs::FunctionId(f.id),
+            AssocItem::Const(c) => ValueNs::ConstId(c.id),
             AssocItem::TypeAlias(_) => unreachable!(),
         };
         let substs = Substs::build_for_def(self.db, item)
@@ -193,8 +195,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             method_resolution::LookupMode::Path,
             move |_ty, item| {
                 let def = match item {
-                    AssocItem::Function(f) => ValueNs::Function(f),
-                    AssocItem::Const(c) => ValueNs::Const(c),
+                    AssocItem::Function(f) => ValueNs::FunctionId(f.id),
+                    AssocItem::Const(c) => ValueNs::ConstId(c.id),
                     AssocItem::TypeAlias(_) => unreachable!(),
                 };
                 let substs = match item.container(self.db) {
@@ -224,9 +226,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn find_self_types(&self, def: &ValueNs, actual_def_ty: Ty) -> Option<Substs> {
-        if let ValueNs::Function(func) = def {
+        if let ValueNs::FunctionId(func) = def {
+            let func = Function::from(*func);
             // We only do the infer if parent has generic params
-            let gen = func.generic_params(self.db);
+            let gen = self.db.generic_params(func.id.into());
             if gen.count_parent_params() == 0 {
                 return None;
             }