Initial support for lang items.

2 files changed, 63 insertions, 29 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 7ca1ff595..2275ac151 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -462,6 +462,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         let remaining_index = remaining_index.unwrap_or(path.segments.len());
         let mut actual_def_ty: Option<Ty> = None;
 
+        let krate = resolver.module().map(|t| t.0.krate());
         // resolve intermediate segments
         for (i, segment) in path.segments[remaining_index..].iter().enumerate() {
             let ty = match resolved {
@@ -500,38 +501,41 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             // Attempt to find an impl_item for the type which has a name matching
             // the current segment
             log::debug!("looking for path segment: {:?}", segment);
+
             actual_def_ty = Some(ty.clone());
 
-            let item: crate::ModuleDef = ty.iterate_impl_items(self.db, |item| {
-                let matching_def: Option<crate::ModuleDef> = match item {
-                    crate::ImplItem::Method(func) => {
-                        let sig = func.signature(self.db);
-                        if segment.name == *sig.name() {
-                            Some(func.into())
-                        } else {
-                            None
+            let item: crate::ModuleDef = krate.and_then(|k| {
+                ty.iterate_impl_items(self.db, k, |item| {
+                    let matching_def: Option<crate::ModuleDef> = match item {
+                        crate::ImplItem::Method(func) => {
+                            let sig = func.signature(self.db);
+                            if segment.name == *sig.name() {
+                                Some(func.into())
+                            } else {
+                                None
+                            }
                         }
-                    }
 
-                    crate::ImplItem::Const(konst) => {
-                        let sig = konst.signature(self.db);
-                        if segment.name == *sig.name() {
-                            Some(konst.into())
-                        } else {
-                            None
+                        crate::ImplItem::Const(konst) => {
+                            let sig = konst.signature(self.db);
+                            if segment.name == *sig.name() {
+                                Some(konst.into())
+                            } else {
+                                None
+                            }
                         }
-                    }
 
-                    // FIXME: Resolve associated types
-                    crate::ImplItem::TypeAlias(_) => None,
-                };
-                match matching_def {
-                    Some(_) => {
-                        self.write_assoc_resolution(id, item);
-                        return matching_def;
+                        // FIXME: Resolve associated types
+                        crate::ImplItem::TypeAlias(_) => None,
+                    };
+                    match matching_def {
+                        Some(_) => {
+                            self.write_assoc_resolution(id, item);
+                            return matching_def;
+                        }
+                        None => None,
                     }
-                    None => None,
-                }
+                })
             })?;
 
             resolved = Resolution::Def(item.into());
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 667b66095..ba516313c 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -14,6 +14,8 @@ use crate::{
     resolve::Resolver,
     traits::TraitItem,
     generics::HasGenericParams,
+    lang_item::lang_item_lookup,
+    ty::primitive::{UncertainIntTy, UncertainFloatTy}
 };
 use super::{TraitRef, Substs};
 
@@ -110,10 +112,33 @@ impl CrateImplBlocks {
     }
 }
 
-fn def_crate(db: &impl HirDatabase, ty: &Ty) -> Option<Crate> {
+/// Rudimentary check whether an impl exists for a given type and trait; this
+/// will actually be done by chalk.
+pub(crate) fn implements(db: &impl HirDatabase, trait_ref: TraitRef) -> bool {
+    // FIXME use all trait impls in the whole crate graph
+    let krate = trait_ref.trait_.module(db).krate(db);
+    let krate = match krate {
+        Some(krate) => krate,
+        None => return false,
+    };
+    let crate_impl_blocks = db.impls_in_crate(krate);
+    let mut impl_blocks = crate_impl_blocks.lookup_impl_blocks_for_trait(&trait_ref.trait_);
+    impl_blocks.any(|impl_block| &impl_block.target_ty(db) == trait_ref.self_ty())
+}
+
+fn def_crate(db: &impl HirDatabase, cur_krate: Crate, ty: &Ty) -> Option<Crate> {
     match ty {
         Ty::Apply(a_ty) => match a_ty.ctor {
             TypeCtor::Adt(def_id) => def_id.krate(db),
+            TypeCtor::Bool => lang_item_lookup(db, cur_krate, "bool")?.krate(db),
+            TypeCtor::Char => lang_item_lookup(db, cur_krate, "char")?.krate(db),
+            TypeCtor::Float(UncertainFloatTy::Known(f)) => {
+                lang_item_lookup(db, cur_krate, f.ty_to_string())?.krate(db)
+            }
+            TypeCtor::Int(UncertainIntTy::Known(i)) => {
+                lang_item_lookup(db, cur_krate, i.ty_to_string())?.krate(db)
+            }
+            TypeCtor::Str => lang_item_lookup(db, cur_krate, "str")?.krate(db),
             _ => None,
         },
         _ => None,
@@ -150,8 +175,11 @@ impl Ty {
         // find in the end takes &self, we still do the autoderef step (just as
         // rustc does an autoderef and then autoref again).
 
+        let krate = resolver.module().map(|t| t.0.krate())?;
         for derefed_ty in self.autoderef(db) {
-            if let Some(result) = derefed_ty.iterate_inherent_methods(db, name, &mut callback) {
+            if let Some(result) =
+                derefed_ty.iterate_inherent_methods(db, name, krate, &mut callback)
+            {
                 return Some(result);
             }
             if let Some(result) =
@@ -208,9 +236,10 @@ impl Ty {
         &self,
         db: &impl HirDatabase,
         name: Option<&Name>,
+        krate: Crate,
         mut callback: impl FnMut(&Ty, Function) -> Option<T>,
     ) -> Option<T> {
-        let krate = match def_crate(db, self) {
+        let krate = match def_crate(db, krate, self) {
             Some(krate) => krate,
             None => return None,
         };
@@ -239,9 +268,10 @@ impl Ty {
     pub fn iterate_impl_items<T>(
         self,
         db: &impl HirDatabase,
+        krate: Crate,
         mut callback: impl FnMut(ImplItem) -> Option<T>,
     ) -> Option<T> {
-        let krate = def_crate(db, &self)?;
+        let krate = def_crate(db, krate, &self)?;
         let impls = db.impls_in_crate(krate);
 
         for impl_block in impls.lookup_impl_blocks(&self) {