From bed6869865ccfc6e72be26cb2041d83ab5cdbe3c Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 26 Nov 2019 22:56:07 +0300
Subject: Cleanup

---
 crates/ra_hir/src/ty/method_resolution.rs | 101 ++++++++++++------------------
 1 file changed, 39 insertions(+), 62 deletions(-)

(limited to 'crates/ra_hir/src/ty/method_resolution.rs')

diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index fdc87a28d..92645e2a5 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -97,14 +97,15 @@ impl CrateImplBlocks {
     }
 }
 
-fn def_crates(
-    db: &impl HirDatabase,
-    cur_crate: CrateId,
-    ty: &Ty,
-) -> Option<ArrayVec<[CrateId; 2]>> {
-    // Types like slice can have inherent impls in several crates, (core and alloc).
-    // The corresponding impls are marked with lang items, so we can use them to find the required crates.
-    macro_rules! lang_item_crate {
+impl Ty {
+    pub(crate) fn def_crates(
+        &self,
+        db: &impl HirDatabase,
+        cur_crate: CrateId,
+    ) -> Option<ArrayVec<[CrateId; 2]>> {
+        // Types like slice can have inherent impls in several crates, (core and alloc).
+        // The corresponding impls are marked with lang items, so we can use them to find the required crates.
+        macro_rules! lang_item_crate {
         ($($name:expr),+ $(,)?) => {{
             let mut v = ArrayVec::<[LangItemTarget; 2]>::new();
             $(
@@ -114,38 +115,38 @@ fn def_crates(
         }};
     }
 
-    let lang_item_targets = match ty {
-        Ty::Apply(a_ty) => match a_ty.ctor {
-            TypeCtor::Adt(def_id) => {
-                return Some(std::iter::once(def_id.module(db).krate).collect())
-            }
-            TypeCtor::Bool => lang_item_crate!("bool"),
-            TypeCtor::Char => lang_item_crate!("char"),
-            TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
-                // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
-                FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
-                FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
+        let lang_item_targets = match self {
+            Ty::Apply(a_ty) => match a_ty.ctor {
+                TypeCtor::Adt(def_id) => {
+                    return Some(std::iter::once(def_id.module(db).krate).collect())
+                }
+                TypeCtor::Bool => lang_item_crate!("bool"),
+                TypeCtor::Char => lang_item_crate!("char"),
+                TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
+                    // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
+                    FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
+                    FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
+                },
+                TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
+                TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
+                TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
+                TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
+                TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
+                _ => return None,
             },
-            TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
-            TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
-            TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
-            TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
-            TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
             _ => return None,
-        },
-        _ => return None,
-    };
-    let res = lang_item_targets
-        .into_iter()
-        .filter_map(|it| match it {
-            LangItemTarget::ImplBlockId(it) => Some(it),
-            _ => None,
-        })
-        .map(|it| it.module(db).krate)
-        .collect();
-    Some(res)
+        };
+        let res = lang_item_targets
+            .into_iter()
+            .filter_map(|it| match it {
+                LangItemTarget::ImplBlockId(it) => Some(it),
+                _ => None,
+            })
+            .map(|it| it.module(db).krate)
+            .collect();
+        Some(res)
+    }
 }
-
 /// Look up the method with the given name, returning the actual autoderefed
 /// receiver type (but without autoref applied yet).
 pub(crate) fn lookup_method(
@@ -286,7 +287,7 @@ fn iterate_inherent_methods<T>(
     krate: CrateId,
     mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
 ) -> Option<T> {
-    for krate in def_crates(db, krate, &ty.value)? {
+    for krate in ty.value.def_crates(db, krate)? {
         let impls = db.impls_in_crate(krate);
 
         for impl_block in impls.lookup_impl_blocks(&ty.value) {
@@ -342,30 +343,6 @@ pub(crate) fn implements_trait(
     solution.is_some()
 }
 
-impl Ty {
-    // This would be nicer if it just returned an iterator, but that runs into
-    // lifetime problems, because we need to borrow temp `CrateImplBlocks`.
-    pub fn iterate_impl_items<T>(
-        self,
-        db: &impl HirDatabase,
-        krate: CrateId,
-        mut callback: impl FnMut(AssocItem) -> Option<T>,
-    ) -> Option<T> {
-        for krate in def_crates(db, krate, &self)? {
-            let impls = db.impls_in_crate(krate);
-
-            for impl_block in impls.lookup_impl_blocks(&self) {
-                for &item in db.impl_data(impl_block).items.iter() {
-                    if let Some(result) = callback(item.into()) {
-                        return Some(result);
-                    }
-                }
-            }
-        }
-        None
-    }
-}
-
 /// This creates Substs for a trait with the given Self type and type variables
 /// for all other parameters, to query Chalk with it.
 fn generic_implements_goal(
-- 
cgit v1.2.3