aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--crates/ra_hir/src/code_model.rs51
-rw-r--r--crates/ra_hir/src/db.rs21
-rw-r--r--crates/ra_hir/src/source_binder.rs4
-rw-r--r--crates/ra_hir/src/ty/lower.rs2
-rw-r--r--crates/ra_hir/src/ty/method_resolution.rs129
-rw-r--r--crates/ra_hir/src/ty/traits.rs16
-rw-r--r--crates/ra_hir/src/ty/traits/chalk.rs2
-rw-r--r--crates/ra_hir_def/src/resolver.rs4
-rw-r--r--crates/ra_ide_api/src/completion/complete_path.rs2
9 files changed, 118 insertions, 113 deletions
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index a842dfed6..54da937ea 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -28,7 +28,8 @@ use crate::{
28 expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId}, 28 expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
29 ty::display::HirFormatter, 29 ty::display::HirFormatter,
30 ty::{ 30 ty::{
31 self, InEnvironment, InferenceResult, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk, 31 self, InEnvironment, InferenceResult, TraitEnvironment, TraitRef, Ty, TyDefId, TypeCtor,
32 TypeWalk,
32 }, 33 },
33 CallableDef, Either, HirDisplay, Name, Source, 34 CallableDef, Either, HirDisplay, Name, Source,
34}; 35};
@@ -498,12 +499,9 @@ impl Adt {
498 let subst = db.generic_defaults(self.into()); 499 let subst = db.generic_defaults(self.into());
499 subst.iter().any(|ty| ty == &Ty::Unknown) 500 subst.iter().any(|ty| ty == &Ty::Unknown)
500 } 501 }
501 pub fn ty(self, db: &impl HirDatabase) -> Ty { 502 pub fn ty(self, db: &impl HirDatabase) -> Type {
502 match self { 503 let id = AdtId::from(self);
503 Adt::Struct(it) => it.ty(db), 504 Type::from_def(db, id.module(db).krate, id)
504 Adt::Union(it) => it.ty(db),
505 Adt::Enum(it) => it.ty(db),
506 }
507 } 505 }
508 506
509 pub fn module(self, db: &impl DefDatabase) -> Module { 507 pub fn module(self, db: &impl DefDatabase) -> Module {
@@ -795,8 +793,8 @@ impl TypeAlias {
795 db.type_alias_data(self.id).type_ref.clone() 793 db.type_alias_data(self.id).type_ref.clone()
796 } 794 }
797 795
798 pub fn ty(self, db: &impl HirDatabase) -> Ty { 796 pub fn ty(self, db: &impl HirDatabase) -> Type {
799 db.ty(self.id.into()) 797 Type::from_def(db, self.id.lookup(db).module(db).krate, self.id)
800 } 798 }
801 799
802 pub fn name(self, db: &impl DefDatabase) -> Name { 800 pub fn name(self, db: &impl DefDatabase) -> Name {
@@ -945,7 +943,7 @@ impl ImplBlock {
945 } 943 }
946 pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplBlock> { 944 pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplBlock> {
947 let impls = db.impls_in_crate(krate.crate_id); 945 let impls = db.impls_in_crate(krate.crate_id);
948 impls.lookup_impl_blocks_for_trait(trait_).map(Self::from).collect() 946 impls.lookup_impl_blocks_for_trait(trait_.id).map(Self::from).collect()
949 } 947 }
950 948
951 pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> { 949 pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
@@ -989,6 +987,17 @@ pub struct Type {
989} 987}
990 988
991impl Type { 989impl Type {
990 fn from_def(
991 db: &impl HirDatabase,
992 krate: CrateId,
993 def: impl HasResolver + Into<TyDefId>,
994 ) -> Type {
995 let resolver = def.resolver(db);
996 let environment = TraitEnvironment::lower(db, &resolver);
997 let ty = db.ty(def.into());
998 Type { krate, ty: InEnvironment { value: ty, environment } }
999 }
1000
992 pub fn is_bool(&self) -> bool { 1001 pub fn is_bool(&self) -> bool {
993 match &self.ty.value { 1002 match &self.ty.value {
994 Ty::Apply(a_ty) => match a_ty.ctor { 1003 Ty::Apply(a_ty) => match a_ty.ctor {
@@ -1097,6 +1106,28 @@ impl Type {
1097 .map(move |ty| self.derived(ty)) 1106 .map(move |ty| self.derived(ty))
1098 } 1107 }
1099 1108
1109 // This would be nicer if it just returned an iterator, but that runs into
1110 // lifetime problems, because we need to borrow temp `CrateImplBlocks`.
1111 pub fn iterate_impl_items<T>(
1112 self,
1113 db: &impl HirDatabase,
1114 krate: Crate,
1115 mut callback: impl FnMut(AssocItem) -> Option<T>,
1116 ) -> Option<T> {
1117 for krate in self.ty.value.def_crates(db, krate.crate_id)? {
1118 let impls = db.impls_in_crate(krate);
1119
1120 for impl_block in impls.lookup_impl_blocks(&self.ty.value) {
1121 for &item in db.impl_data(impl_block).items.iter() {
1122 if let Some(result) = callback(item.into()) {
1123 return Some(result);
1124 }
1125 }
1126 }
1127 }
1128 None
1129 }
1130
1100 // FIXME: remove 1131 // FIXME: remove
1101 pub fn into_ty(self) -> Ty { 1132 pub fn into_ty(self) -> Ty {
1102 self.ty.value 1133 self.ty.value
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 3b5aa7516..31b21ca84 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,6 +2,7 @@
2 2
3use std::sync::Arc; 3use std::sync::Arc;
4 4
5use hir_def::{GenericDefId, LocalStructFieldId, TraitId, VariantId};
5use ra_arena::map::ArenaMap; 6use ra_arena::map::ArenaMap;
6use ra_db::{salsa, CrateId}; 7use ra_db::{salsa, CrateId};
7 8
@@ -12,19 +13,15 @@ use crate::{
12 CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, Ty, TyDefId, TypeCtor, 13 CallableDef, FnSig, GenericPredicate, InferenceResult, Substs, Ty, TyDefId, TypeCtor,
13 ValueTyDefId, 14 ValueTyDefId,
14 }, 15 },
15 Crate, DefWithBody, ImplBlock, Trait, 16 Crate, DefWithBody, ImplBlock,
16}; 17};
17 18
18pub use hir_def::{ 19pub use hir_def::db::{
19 db::{ 20 BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
20 BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery, 21 DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
21 DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery, 22 FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
22 FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, 23 LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, RawItemsWithSourceMapQuery,
23 InternDatabaseStorage, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, 24 StaticDataQuery, StructDataQuery, TraitDataQuery, TypeAliasDataQuery,
24 RawItemsWithSourceMapQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
25 TypeAliasDataQuery,
26 },
27 GenericDefId, LocalStructFieldId, VariantId,
28}; 25};
29pub use hir_expand::db::{ 26pub use hir_expand::db::{
30 AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, 27 AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -66,7 +63,7 @@ pub trait HirDatabase: DefDatabase {
66 fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplBlocks>; 63 fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplBlocks>;
67 64
68 #[salsa::invoke(crate::ty::traits::impls_for_trait_query)] 65 #[salsa::invoke(crate::ty::traits::impls_for_trait_query)]
69 fn impls_for_trait(&self, krate: Crate, trait_: Trait) -> Arc<[ImplBlock]>; 66 fn impls_for_trait(&self, krate: CrateId, trait_: TraitId) -> Arc<[ImplBlock]>;
70 67
71 /// This provides the Chalk trait solver instance. Because Chalk always 68 /// This provides the Chalk trait solver instance. Because Chalk always
72 /// works from a specific crate, this query is keyed on the crate; and 69 /// works from a specific crate, this query is keyed on the crate; and
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 7c4ebd4b4..9f3e6c43f 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -389,14 +389,14 @@ impl SourceAnalyzer {
389 pub fn iterate_path_candidates<T>( 389 pub fn iterate_path_candidates<T>(
390 &self, 390 &self,
391 db: &impl HirDatabase, 391 db: &impl HirDatabase,
392 ty: Ty, 392 ty: &Type,
393 name: Option<&Name>, 393 name: Option<&Name>,
394 callback: impl FnMut(&Ty, AssocItem) -> Option<T>, 394 callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
395 ) -> Option<T> { 395 ) -> Option<T> {
396 // There should be no inference vars in types passed here 396 // There should be no inference vars in types passed here
397 // FIXME check that? 397 // FIXME check that?
398 // FIXME replace Unknown by bound vars here 398 // FIXME replace Unknown by bound vars here
399 let canonical = crate::ty::Canonical { value: ty, num_vars: 0 }; 399 let canonical = crate::ty::Canonical { value: ty.ty.value.clone(), num_vars: 0 };
400 method_resolution::iterate_method_candidates( 400 method_resolution::iterate_method_candidates(
401 &canonical, 401 &canonical,
402 db, 402 db,
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 709492d21..1c0f71adc 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -189,7 +189,7 @@ impl Ty {
189 Ty::Param { idx, name } 189 Ty::Param { idx, name }
190 } 190 }
191 TypeNs::SelfType(impl_block) => ImplBlock::from(impl_block).target_ty(db), 191 TypeNs::SelfType(impl_block) => ImplBlock::from(impl_block).target_ty(db),
192 TypeNs::AdtSelfType(adt) => Adt::from(adt).ty(db), 192 TypeNs::AdtSelfType(adt) => db.ty(adt.into()),
193 193
194 TypeNs::AdtId(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()), 194 TypeNs::AdtId(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()),
195 TypeNs::BuiltinType(it) => { 195 TypeNs::BuiltinType(it) => {
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index f1bc638ee..92645e2a5 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -6,9 +6,10 @@ use std::sync::Arc;
6 6
7use arrayvec::ArrayVec; 7use arrayvec::ArrayVec;
8use hir_def::{ 8use hir_def::{
9 lang_item::LangItemTarget, resolver::HasResolver, resolver::Resolver, AssocItemId, AstItemDef, 9 lang_item::LangItemTarget, resolver::HasResolver, resolver::Resolver, type_ref::Mutability,
10 HasModule, ImplId, TraitId, 10 AssocItemId, AstItemDef, HasModule, ImplId, TraitId,
11}; 11};
12use hir_expand::name::Name;
12use ra_db::CrateId; 13use ra_db::CrateId;
13use ra_prof::profile; 14use ra_prof::profile;
14use rustc_hash::FxHashMap; 15use rustc_hash::FxHashMap;
@@ -17,7 +18,7 @@ use crate::{
17 db::HirDatabase, 18 db::HirDatabase,
18 ty::primitive::{FloatBitness, Uncertain}, 19 ty::primitive::{FloatBitness, Uncertain},
19 ty::{utils::all_super_traits, Ty, TypeCtor}, 20 ty::{utils::all_super_traits, Ty, TypeCtor},
20 AssocItem, Crate, Function, Mutability, Name, Trait, 21 AssocItem, Function,
21}; 22};
22 23
23use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef}; 24use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@@ -87,8 +88,8 @@ impl CrateImplBlocks {
87 fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied() 88 fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied()
88 } 89 }
89 90
90 pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator<Item = ImplId> + '_ { 91 pub fn lookup_impl_blocks_for_trait(&self, tr: TraitId) -> impl Iterator<Item = ImplId> + '_ {
91 self.impls_by_trait.get(&tr.id).into_iter().flatten().copied() 92 self.impls_by_trait.get(&tr).into_iter().flatten().copied()
92 } 93 }
93 94
94 pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplId> + 'a { 95 pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplId> + 'a {
@@ -96,51 +97,56 @@ impl CrateImplBlocks {
96 } 97 }
97} 98}
98 99
99fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayVec<[Crate; 2]>> { 100impl Ty {
100 // Types like slice can have inherent impls in several crates, (core and alloc). 101 pub(crate) fn def_crates(
101 // The corresponding impls are marked with lang items, so we can use them to find the required crates. 102 &self,
102 macro_rules! lang_item_crate { 103 db: &impl HirDatabase,
104 cur_crate: CrateId,
105 ) -> Option<ArrayVec<[CrateId; 2]>> {
106 // Types like slice can have inherent impls in several crates, (core and alloc).
107 // The corresponding impls are marked with lang items, so we can use them to find the required crates.
108 macro_rules! lang_item_crate {
103 ($($name:expr),+ $(,)?) => {{ 109 ($($name:expr),+ $(,)?) => {{
104 let mut v = ArrayVec::<[LangItemTarget; 2]>::new(); 110 let mut v = ArrayVec::<[LangItemTarget; 2]>::new();
105 $( 111 $(
106 v.extend(db.lang_item(cur_crate.crate_id, $name.into())); 112 v.extend(db.lang_item(cur_crate, $name.into()));
107 )+ 113 )+
108 v 114 v
109 }}; 115 }};
110 } 116 }
111 117
112 let lang_item_targets = match ty { 118 let lang_item_targets = match self {
113 Ty::Apply(a_ty) => match a_ty.ctor { 119 Ty::Apply(a_ty) => match a_ty.ctor {
114 TypeCtor::Adt(def_id) => { 120 TypeCtor::Adt(def_id) => {
115 return Some(std::iter::once(def_id.module(db).krate.into()).collect()) 121 return Some(std::iter::once(def_id.module(db).krate).collect())
116 } 122 }
117 TypeCtor::Bool => lang_item_crate!("bool"), 123 TypeCtor::Bool => lang_item_crate!("bool"),
118 TypeCtor::Char => lang_item_crate!("char"), 124 TypeCtor::Char => lang_item_crate!("char"),
119 TypeCtor::Float(Uncertain::Known(f)) => match f.bitness { 125 TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
120 // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime) 126 // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
121 FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"), 127 FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
122 FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"), 128 FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
129 },
130 TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
131 TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
132 TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
133 TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
134 TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
135 _ => return None,
123 }, 136 },
124 TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
125 TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
126 TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
127 TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
128 TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
129 _ => return None, 137 _ => return None,
130 }, 138 };
131 _ => return None, 139 let res = lang_item_targets
132 }; 140 .into_iter()
133 let res = lang_item_targets 141 .filter_map(|it| match it {
134 .into_iter() 142 LangItemTarget::ImplBlockId(it) => Some(it),
135 .filter_map(|it| match it { 143 _ => None,
136 LangItemTarget::ImplBlockId(it) => Some(it), 144 })
137 _ => None, 145 .map(|it| it.module(db).krate)
138 }) 146 .collect();
139 .map(|it| it.module(db).krate.into()) 147 Some(res)
140 .collect(); 148 }
141 Some(res)
142} 149}
143
144/// Look up the method with the given name, returning the actual autoderefed 150/// Look up the method with the given name, returning the actual autoderefed
145/// receiver type (but without autoref applied yet). 151/// receiver type (but without autoref applied yet).
146pub(crate) fn lookup_method( 152pub(crate) fn lookup_method(
@@ -193,14 +199,9 @@ pub(crate) fn iterate_method_candidates<T>(
193 let environment = TraitEnvironment::lower(db, resolver); 199 let environment = TraitEnvironment::lower(db, resolver);
194 let ty = InEnvironment { value: ty.clone(), environment }; 200 let ty = InEnvironment { value: ty.clone(), environment };
195 for derefed_ty in autoderef::autoderef(db, resolver.krate(), ty) { 201 for derefed_ty in autoderef::autoderef(db, resolver.krate(), ty) {
196 if let Some(result) = iterate_inherent_methods( 202 if let Some(result) =
197 &derefed_ty, 203 iterate_inherent_methods(&derefed_ty, db, name, mode, krate, &mut callback)
198 db, 204 {
199 name,
200 mode,
201 krate.into(),
202 &mut callback,
203 ) {
204 return Some(result); 205 return Some(result);
205 } 206 }
206 if let Some(result) = iterate_trait_method_candidates( 207 if let Some(result) = iterate_trait_method_candidates(
@@ -283,11 +284,11 @@ fn iterate_inherent_methods<T>(
283 db: &impl HirDatabase, 284 db: &impl HirDatabase,
284 name: Option<&Name>, 285 name: Option<&Name>,
285 mode: LookupMode, 286 mode: LookupMode,
286 krate: Crate, 287 krate: CrateId,
287 mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>, 288 mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
288) -> Option<T> { 289) -> Option<T> {
289 for krate in def_crates(db, krate, &ty.value)? { 290 for krate in ty.value.def_crates(db, krate)? {
290 let impls = db.impls_in_crate(krate.crate_id); 291 let impls = db.impls_in_crate(krate);
291 292
292 for impl_block in impls.lookup_impl_blocks(&ty.value) { 293 for impl_block in impls.lookup_impl_blocks(&ty.value) {
293 for &item in db.impl_data(impl_block).items.iter() { 294 for &item in db.impl_data(impl_block).items.iter() {
@@ -327,7 +328,7 @@ pub(crate) fn implements_trait(
327 ty: &Canonical<Ty>, 328 ty: &Canonical<Ty>,
328 db: &impl HirDatabase, 329 db: &impl HirDatabase,
329 resolver: &Resolver, 330 resolver: &Resolver,
330 krate: Crate, 331 krate: CrateId,
331 trait_: TraitId, 332 trait_: TraitId,
332) -> bool { 333) -> bool {
333 if ty.value.inherent_trait() == Some(trait_) { 334 if ty.value.inherent_trait() == Some(trait_) {
@@ -337,35 +338,11 @@ pub(crate) fn implements_trait(
337 } 338 }
338 let env = TraitEnvironment::lower(db, resolver); 339 let env = TraitEnvironment::lower(db, resolver);
339 let goal = generic_implements_goal(db, env, trait_, ty.clone()); 340 let goal = generic_implements_goal(db, env, trait_, ty.clone());
340 let solution = db.trait_solve(krate, goal); 341 let solution = db.trait_solve(krate.into(), goal);
341 342
342 solution.is_some() 343 solution.is_some()
343} 344}
344 345
345impl Ty {
346 // This would be nicer if it just returned an iterator, but that runs into
347 // lifetime problems, because we need to borrow temp `CrateImplBlocks`.
348 pub fn iterate_impl_items<T>(
349 self,
350 db: &impl HirDatabase,
351 krate: Crate,
352 mut callback: impl FnMut(AssocItem) -> Option<T>,
353 ) -> Option<T> {
354 for krate in def_crates(db, krate, &self)? {
355 let impls = db.impls_in_crate(krate.crate_id);
356
357 for impl_block in impls.lookup_impl_blocks(&self) {
358 for &item in db.impl_data(impl_block).items.iter() {
359 if let Some(result) = callback(item.into()) {
360 return Some(result);
361 }
362 }
363 }
364 }
365 None
366 }
367}
368
369/// This creates Substs for a trait with the given Self type and type variables 346/// This creates Substs for a trait with the given Self type and type variables
370/// for all other parameters, to query Chalk with it. 347/// for all other parameters, to query Chalk with it.
371fn generic_implements_goal( 348fn generic_implements_goal(
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index a91c2476b..637e21e9c 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -2,13 +2,13 @@
2use std::sync::{Arc, Mutex}; 2use std::sync::{Arc, Mutex};
3 3
4use chalk_ir::{cast::Cast, family::ChalkIr}; 4use chalk_ir::{cast::Cast, family::ChalkIr};
5use hir_def::{expr::ExprId, DefWithBodyId}; 5use hir_def::{expr::ExprId, DefWithBodyId, TraitId};
6use log::debug; 6use log::debug;
7use ra_db::{impl_intern_key, salsa}; 7use ra_db::{impl_intern_key, salsa, CrateId};
8use ra_prof::profile; 8use ra_prof::profile;
9use rustc_hash::FxHashSet; 9use rustc_hash::FxHashSet;
10 10
11use crate::{db::HirDatabase, Crate, ImplBlock, Trait, TypeAlias}; 11use crate::{db::HirDatabase, Crate, ImplBlock, TypeAlias};
12 12
13use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk}; 13use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
14 14
@@ -77,8 +77,8 @@ pub(crate) fn trait_solver_query(
77/// Collects impls for the given trait in the whole dependency tree of `krate`. 77/// Collects impls for the given trait in the whole dependency tree of `krate`.
78pub(crate) fn impls_for_trait_query( 78pub(crate) fn impls_for_trait_query(
79 db: &impl HirDatabase, 79 db: &impl HirDatabase,
80 krate: Crate, 80 krate: CrateId,
81 trait_: Trait, 81 trait_: TraitId,
82) -> Arc<[ImplBlock]> { 82) -> Arc<[ImplBlock]> {
83 let mut impls = FxHashSet::default(); 83 let mut impls = FxHashSet::default();
84 // We call the query recursively here. On the one hand, this means we can 84 // We call the query recursively here. On the one hand, this means we can
@@ -86,10 +86,10 @@ pub(crate) fn impls_for_trait_query(
86 // will only ever get called for a few crates near the root of the tree (the 86 // will only ever get called for a few crates near the root of the tree (the
87 // ones the user is editing), so this may actually be a waste of memory. I'm 87 // ones the user is editing), so this may actually be a waste of memory. I'm
88 // doing it like this mainly for simplicity for now. 88 // doing it like this mainly for simplicity for now.
89 for dep in krate.dependencies(db) { 89 for dep in db.crate_graph().dependencies(krate) {
90 impls.extend(db.impls_for_trait(dep.krate, trait_).iter()); 90 impls.extend(db.impls_for_trait(dep.crate_id, trait_).iter());
91 } 91 }
92 let crate_impl_blocks = db.impls_in_crate(krate.crate_id); 92 let crate_impl_blocks = db.impls_in_crate(krate);
93 impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_).map(ImplBlock::from)); 93 impls.extend(crate_impl_blocks.lookup_impl_blocks_for_trait(trait_).map(ImplBlock::from));
94 impls.into_iter().collect() 94 impls.into_iter().collect()
95} 95}
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 4b0f4f56c..d879382a0 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -448,7 +448,7 @@ where
448 let trait_: TraitId = from_chalk(self.db, trait_id); 448 let trait_: TraitId = from_chalk(self.db, trait_id);
449 let mut result: Vec<_> = self 449 let mut result: Vec<_> = self
450 .db 450 .db
451 .impls_for_trait(self.krate, trait_.into()) 451 .impls_for_trait(self.krate.crate_id, trait_.into())
452 .iter() 452 .iter()
453 .copied() 453 .copied()
454 .map(Impl::ImplBlock) 454 .map(Impl::ImplBlock)
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index c40f41717..5155365cc 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -484,7 +484,7 @@ impl Resolver {
484 } 484 }
485} 485}
486 486
487pub trait HasResolver { 487pub trait HasResolver: Copy {
488 /// Builds a resolver for type references inside this def. 488 /// Builds a resolver for type references inside this def.
489 fn resolver(self, db: &impl DefDatabase) -> Resolver; 489 fn resolver(self, db: &impl DefDatabase) -> Resolver;
490} 490}
@@ -502,7 +502,7 @@ impl HasResolver for TraitId {
502 } 502 }
503} 503}
504 504
505impl<T: Into<AdtId>> HasResolver for T { 505impl<T: Into<AdtId> + Copy> HasResolver for T {
506 fn resolver(self, db: &impl DefDatabase) -> Resolver { 506 fn resolver(self, db: &impl DefDatabase) -> Resolver {
507 let def = self.into(); 507 let def = self.into();
508 def.module(db) 508 def.module(db)
diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs
index 63e25e0bf..89e0009a1 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -50,7 +50,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
50 hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db), 50 hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
51 _ => unreachable!(), 51 _ => unreachable!(),
52 }; 52 };
53 ctx.analyzer.iterate_path_candidates(ctx.db, ty.clone(), None, |_ty, item| { 53 ctx.analyzer.iterate_path_candidates(ctx.db, &ty, None, |_ty, item| {
54 match item { 54 match item {
55 hir::AssocItem::Function(func) => { 55 hir::AssocItem::Function(func) => {
56 if !func.has_self_param(ctx.db) { 56 if !func.has_self_param(ctx.db) {