Merge #2426

2426: Decouple r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

5 files changed, 68 insertions, 50 deletions

diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index cf45ede7c..3fb5d8a83 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -7,6 +7,7 @@
 use hir_def::{
     lang_item::LangItemTarget,
     resolver::{HasResolver, Resolver},
+    type_ref::Mutability,
     AdtId,
 };
 use rustc_hash::FxHashMap;
@@ -15,7 +16,6 @@ use test_utils::tested_by;
 use crate::{
     db::HirDatabase,
     ty::{autoderef, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
-    Mutability,
 };
 
 use super::{InEnvironment, InferTy, InferenceContext, TypeVarValue};
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index eb221d6bc..57f845dfa 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -5,22 +5,21 @@ use std::sync::Arc;
 
 use hir_def::{
     builtin_type::Signedness,
+    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     generics::GenericParams,
     path::{GenericArg, GenericArgs},
     resolver::resolver_for_expr,
     AdtId, ContainerId, Lookup, StructFieldId,
 };
-use hir_expand::name;
+use hir_expand::name::{self, Name};
 
 use crate::{
     db::HirDatabase,
-    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     ty::{
         autoderef, method_resolution, op, traits::InEnvironment, CallableDef, InferTy, IntTy,
         Mutability, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
         TypeWalk, Uncertain,
     },
-    Name,
 };
 
 use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
diff --git a/crates/ra_hir/src/ty/infer/pat.rs b/crates/ra_hir/src/ty/infer/pat.rs
index 641d61e87..6dbf03eb2 100644
--- a/crates/ra_hir/src/ty/infer/pat.rs
+++ b/crates/ra_hir/src/ty/infer/pat.rs
@@ -3,14 +3,18 @@
 use std::iter::repeat;
 use std::sync::Arc;
 
+use hir_def::{
+    expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
+    path::Path,
+    type_ref::Mutability,
+};
+use hir_expand::name::Name;
 use test_utils::tested_by;
 
 use super::{BindingMode, InferenceContext};
 use crate::{
     db::HirDatabase,
-    expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
-    ty::{Mutability, Substs, Ty, TypeCtor, TypeWalk},
-    Name, Path,
+    ty::{Substs, Ty, TypeCtor, TypeWalk},
 };
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
diff --git a/crates/ra_hir/src/ty/infer/path.rs b/crates/ra_hir/src/ty/infer/path.rs
index be2067dd4..09ff79728 100644
--- a/crates/ra_hir/src/ty/infer/path.rs
+++ b/crates/ra_hir/src/ty/infer/path.rs
@@ -1,14 +1,15 @@
 //! Path expression resolution.
 
 use hir_def::{
-    path::PathSegment,
-    resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs},
+    path::{Path, PathSegment},
+    resolver::{HasResolver, ResolveValueResult, Resolver, TypeNs, ValueNs},
+    AssocItemId, ContainerId, Lookup,
 };
+use hir_expand::name::Name;
 
 use crate::{
     db::HirDatabase,
     ty::{method_resolution, Substs, Ty, TypeWalk, ValueTyDefId},
-    AssocItem, Container, Function, Name, Path,
 };
 
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -142,31 +143,35 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         id: ExprOrPatId,
     ) -> Option<(ValueNs, Option<Substs>)> {
         let trait_ = trait_ref.trait_;
-        let item =
-            self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id).into()).find_map(
-                |item| match item {
-                    AssocItem::Function(func) => {
-                        if segment.name == func.name(self.db) {
-                            Some(AssocItem::Function(func))
-                        } else {
-                            None
-                        }
+        let item = self
+            .db
+            .trait_data(trait_)
+            .items
+            .iter()
+            .map(|(_name, id)| (*id).into())
+            .find_map(|item| match item {
+                AssocItemId::FunctionId(func) => {
+                    if segment.name == self.db.function_data(func).name {
+                        Some(AssocItemId::FunctionId(func))
+                    } else {
+                        None
                     }
+                }
 
-                    AssocItem::Const(konst) => {
-                        if konst.name(self.db).map_or(false, |n| n == segment.name) {
-                            Some(AssocItem::Const(konst))
-                        } else {
-                            None
-                        }
+                AssocItemId::ConstId(konst) => {
+                    if self.db.const_data(konst).name.as_ref().map_or(false, |n| n == &segment.name)
+                    {
+                        Some(AssocItemId::ConstId(konst))
+                    } else {
+                        None
                     }
-                    AssocItem::TypeAlias(_) => None,
-                },
-            )?;
+                }
+                AssocItemId::TypeAliasId(_) => None,
+            })?;
         let def = match item {
-            AssocItem::Function(f) => ValueNs::FunctionId(f.id),
-            AssocItem::Const(c) => ValueNs::ConstId(c.id),
-            AssocItem::TypeAlias(_) => unreachable!(),
+            AssocItemId::FunctionId(f) => ValueNs::FunctionId(f),
+            AssocItemId::ConstId(c) => ValueNs::ConstId(c),
+            AssocItemId::TypeAliasId(_) => unreachable!(),
         };
         let substs = Substs::build_for_def(self.db, item)
             .use_parent_substs(&trait_ref.substs)
@@ -196,16 +201,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Some(name),
             method_resolution::LookupMode::Path,
             move |_ty, item| {
-                let def = match item {
-                    AssocItem::Function(f) => ValueNs::FunctionId(f.id),
-                    AssocItem::Const(c) => ValueNs::ConstId(c.id),
-                    AssocItem::TypeAlias(_) => unreachable!(),
+                let (def, container) = match item {
+                    AssocItemId::FunctionId(f) => {
+                        (ValueNs::FunctionId(f), f.lookup(self.db).container)
+                    }
+                    AssocItemId::ConstId(c) => (ValueNs::ConstId(c), c.lookup(self.db).container),
+                    AssocItemId::TypeAliasId(_) => unreachable!(),
                 };
-                let substs = match item.container(self.db) {
-                    Container::ImplBlock(_) => self.find_self_types(&def, ty.clone()),
-                    Container::Trait(t) => {
+                let substs = match container {
+                    ContainerId::ImplId(_) => self.find_self_types(&def, ty.clone()),
+                    ContainerId::TraitId(trait_) => {
                         // we're picking this method
-                        let trait_substs = Substs::build_for_def(self.db, t.id)
+                        let trait_substs = Substs::build_for_def(self.db, trait_)
                             .push(ty.clone())
                             .fill(std::iter::repeat_with(|| self.new_type_var()))
                             .build();
@@ -214,29 +221,35 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             .fill_with_params()
                             .build();
                         self.obligations.push(super::Obligation::Trait(TraitRef {
-                            trait_: t.id,
+                            trait_,
                             substs: trait_substs,
                         }));
                         Some(substs)
                     }
+                    ContainerId::ModuleId(_) => None,
                 };
 
-                self.write_assoc_resolution(id, item);
+                self.write_assoc_resolution(id, item.into());
                 Some((def, substs))
             },
         )
     }
 
     fn find_self_types(&self, def: &ValueNs, actual_def_ty: Ty) -> Option<Substs> {
-        if let ValueNs::FunctionId(func) = def {
-            let func = Function::from(*func);
+        if let ValueNs::FunctionId(func) = *def {
             // We only do the infer if parent has generic params
-            let gen = self.db.generic_params(func.id.into());
+            let gen = self.db.generic_params(func.into());
             if gen.count_parent_params() == 0 {
                 return None;
             }
 
-            let impl_block = func.impl_block(self.db)?.target_ty(self.db);
+            let impl_id = match func.lookup(self.db).container {
+                ContainerId::ImplId(it) => it,
+                _ => return None,
+            };
+            let resolver = impl_id.resolver(self.db);
+            let impl_data = self.db.impl_data(impl_id);
+            let impl_block = Ty::from_hir(self.db, &resolver, &impl_data.target_type);
             let impl_block_substs = impl_block.substs()?;
             let actual_substs = actual_def_ty.substs()?;
 
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index 64d9394cf..e27bb2f82 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -1,12 +1,14 @@
 //! Unification and canonicalization logic.
 
 use super::{InferenceContext, Obligation};
-use crate::db::HirDatabase;
-use crate::ty::{
-    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
-    TypeWalk,
+use crate::{
+    db::HirDatabase,
+    ty::{
+        Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
+        TypeWalk,
+    },
+    util::make_mut_slice,
 };
-use crate::util::make_mut_slice;
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     pub(super) fn canonicalizer<'b>(&'b mut self) -> Canonicalizer<'a, 'b, D>