4 files changed, 161 insertions, 74 deletions

diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 4006f595d..23de2bd6b 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -4,7 +4,7 @@ use std::iter::repeat;
 use std::sync::Arc;
 
 use hir_def::{
-    expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
+    expr::{BindingAnnotation, Expr, Literal, Pat, PatId, RecordFieldPat},
     path::Path,
     type_ref::Mutability,
     FieldId,
@@ -90,18 +90,7 @@ impl<'a> InferenceContext<'a> {
     ) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
 
-        let is_non_ref_pat = match &body[pat] {
-            Pat::Tuple { .. }
-            | Pat::Or(..)
-            | Pat::TupleStruct { .. }
-            | Pat::Record { .. }
-            | Pat::Range { .. }
-            | Pat::Slice { .. } => true,
-            // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
-            Pat::Path(..) | Pat::Lit(..) => true,
-            Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
-        };
-        if is_non_ref_pat {
+        if is_non_ref_pat(&body, pat) {
             while let Some((inner, mutability)) = expected.as_reference() {
                 expected = inner;
                 default_bm = match default_bm {
@@ -227,3 +216,21 @@ impl<'a> InferenceContext<'a> {
         ty
     }
 }
+
+fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
+    match &body[pat] {
+        Pat::Tuple { .. }
+        | Pat::TupleStruct { .. }
+        | Pat::Record { .. }
+        | Pat::Range { .. }
+        | Pat::Slice { .. } => true,
+        Pat::Or(pats) => pats.iter().all(|p| is_non_ref_pat(body, *p)),
+        // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
+        Pat::Path(..) => true,
+        Pat::Lit(expr) => match body[*expr] {
+            Expr::Literal(Literal::String(..)) => false,
+            _ => true,
+        },
+        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+    }
+}
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index ed638c195..8b59a8bd6 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -271,6 +271,33 @@ pub fn iterate_method_candidates<T>(
     mode: LookupMode,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
 ) -> Option<T> {
+    let mut slot = None;
+    iterate_method_candidates_impl(
+        ty,
+        db,
+        env,
+        krate,
+        traits_in_scope,
+        name,
+        mode,
+        &mut |ty, item| {
+            slot = callback(ty, item);
+            slot.is_some()
+        },
+    );
+    slot
+}
+
+pub fn iterate_method_candidates_impl(
+    ty: &Canonical<Ty>,
+    db: &dyn HirDatabase,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
+    name: Option<&Name>,
+    mode: LookupMode,
+    callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
     match mode {
         LookupMode::MethodCall => {
             // For method calls, rust first does any number of autoderef, and then one
@@ -298,19 +325,19 @@ pub fn iterate_method_candidates<T>(
 
             let deref_chain = autoderef_method_receiver(db, krate, ty);
             for i in 0..deref_chain.len() {
-                if let Some(result) = iterate_method_candidates_with_autoref(
+                if iterate_method_candidates_with_autoref(
                     &deref_chain[i..],
                     db,
                     env.clone(),
                     krate,
                     traits_in_scope,
                     name,
-                    &mut callback,
+                    callback,
                 ) {
-                    return Some(result);
+                    return true;
                 }
             }
-            None
+            false
         }
         LookupMode::Path => {
             // No autoderef for path lookups
@@ -321,22 +348,22 @@ pub fn iterate_method_candidates<T>(
                 krate,
                 traits_in_scope,
                 name,
-                &mut callback,
+                callback,
             )
         }
     }
 }
 
-fn iterate_method_candidates_with_autoref<T>(
+fn iterate_method_candidates_with_autoref(
     deref_chain: &[Canonical<Ty>],
     db: &dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     krate: CrateId,
     traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
-    mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
-) -> Option<T> {
-    if let Some(result) = iterate_method_candidates_by_receiver(
+    mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
+    if iterate_method_candidates_by_receiver(
         &deref_chain[0],
         &deref_chain[1..],
         db,
@@ -346,13 +373,13 @@ fn iterate_method_candidates_with_autoref<T>(
         name,
         &mut callback,
     ) {
-        return Some(result);
+        return true;
     }
     let refed = Canonical {
         num_vars: deref_chain[0].num_vars,
         value: Ty::apply_one(TypeCtor::Ref(Mutability::Shared), deref_chain[0].value.clone()),
     };
-    if let Some(result) = iterate_method_candidates_by_receiver(
+    if iterate_method_candidates_by_receiver(
         &refed,
         deref_chain,
         db,
@@ -362,13 +389,13 @@ fn iterate_method_candidates_with_autoref<T>(
         name,
         &mut callback,
     ) {
-        return Some(result);
+        return true;
     }
     let ref_muted = Canonical {
         num_vars: deref_chain[0].num_vars,
         value: Ty::apply_one(TypeCtor::Ref(Mutability::Mut), deref_chain[0].value.clone()),
     };
-    if let Some(result) = iterate_method_candidates_by_receiver(
+    if iterate_method_candidates_by_receiver(
         &ref_muted,
         deref_chain,
         db,
@@ -378,12 +405,12 @@ fn iterate_method_candidates_with_autoref<T>(
         name,
         &mut callback,
     ) {
-        return Some(result);
+        return true;
     }
-    None
+    false
 }
 
-fn iterate_method_candidates_by_receiver<T>(
+fn iterate_method_candidates_by_receiver(
     receiver_ty: &Canonical<Ty>,
     rest_of_deref_chain: &[Canonical<Ty>],
     db: &dyn HirDatabase,
@@ -391,20 +418,18 @@ fn iterate_method_candidates_by_receiver<T>(
     krate: CrateId,
     traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
-    mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
-) -> Option<T> {
+    mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
     // We're looking for methods with *receiver* type receiver_ty. These could
     // be found in any of the derefs of receiver_ty, so we have to go through
     // that.
     for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
-        if let Some(result) =
-            iterate_inherent_methods(self_ty, db, name, Some(receiver_ty), krate, &mut callback)
-        {
-            return Some(result);
+        if iterate_inherent_methods(self_ty, db, name, Some(receiver_ty), krate, &mut callback) {
+            return true;
         }
     }
     for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
-        if let Some(result) = iterate_trait_method_candidates(
+        if iterate_trait_method_candidates(
             self_ty,
             db,
             env.clone(),
@@ -414,40 +439,28 @@ fn iterate_method_candidates_by_receiver<T>(
             Some(receiver_ty),
             &mut callback,
         ) {
-            return Some(result);
+            return true;
         }
     }
-    None
+    false
 }
 
-fn iterate_method_candidates_for_self_ty<T>(
+fn iterate_method_candidates_for_self_ty(
     self_ty: &Canonical<Ty>,
     db: &dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     krate: CrateId,
     traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
-    mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
-) -> Option<T> {
-    if let Some(result) = iterate_inherent_methods(self_ty, db, name, None, krate, &mut callback) {
-        return Some(result);
-    }
-    if let Some(result) = iterate_trait_method_candidates(
-        self_ty,
-        db,
-        env,
-        krate,
-        traits_in_scope,
-        name,
-        None,
-        &mut callback,
-    ) {
-        return Some(result);
+    mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
+    if iterate_inherent_methods(self_ty, db, name, None, krate, &mut callback) {
+        return true;
     }
-    None
+    iterate_trait_method_candidates(self_ty, db, env, krate, traits_in_scope, name, None, callback)
 }
 
-fn iterate_trait_method_candidates<T>(
+fn iterate_trait_method_candidates(
     self_ty: &Canonical<Ty>,
     db: &dyn HirDatabase,
     env: Arc<TraitEnvironment>,
@@ -455,8 +468,8 @@ fn iterate_trait_method_candidates<T>(
     traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     receiver_ty: Option<&Canonical<Ty>>,
-    mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
-) -> Option<T> {
+    callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
     // if ty is `dyn Trait`, the trait doesn't need to be in scope
     let inherent_trait =
         self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t));
@@ -489,23 +502,27 @@ fn iterate_trait_method_candidates<T>(
                 }
             }
             known_implemented = true;
-            if let Some(result) = callback(&self_ty.value, *item) {
-                return Some(result);
+            if callback(&self_ty.value, *item) {
+                return true;
             }
         }
     }
-    None
+    false
 }
 
-fn iterate_inherent_methods<T>(
+fn iterate_inherent_methods(
     self_ty: &Canonical<Ty>,
     db: &dyn HirDatabase,
     name: Option<&Name>,
     receiver_ty: Option<&Canonical<Ty>>,
     krate: CrateId,
-    mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
-) -> Option<T> {
-    for krate in self_ty.value.def_crates(db, krate)? {
+    callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
+) -> bool {
+    let def_crates = match self_ty.value.def_crates(db, krate) {
+        Some(k) => k,
+        None => return false,
+    };
+    for krate in def_crates {
         let impls = db.impls_in_crate(krate);
 
         for impl_def in impls.lookup_impl_defs(&self_ty.value) {
@@ -521,13 +538,13 @@ fn iterate_inherent_methods<T>(
                     test_utils::mark::hit!(impl_self_type_match_without_receiver);
                     continue;
                 }
-                if let Some(result) = callback(&self_ty.value, item) {
-                    return Some(result);
+                if callback(&self_ty.value, item) {
+                    return true;
                 }
             }
         }
     }
-    None
+    false
 }
 
 /// Returns the self type for the index trait call.
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 1fe05c70c..85ff26a36 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -67,8 +67,8 @@ fn type_at_pos_displayed(
     panic!("Can't find expression")
 }
 
-fn type_at(content: &str) -> String {
-    let (db, file_pos) = TestDB::with_position(content);
+fn type_at(ra_fixture: &str) -> String {
+    let (db, file_pos) = TestDB::with_position(ra_fixture);
     type_at_pos(&db, file_pos)
 }
 
@@ -164,13 +164,19 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
     visit_module(&db, &crate_def_map, module.local_id, &mut |it| defs.push(it));
     defs.sort_by_key(|def| match def {
         DefWithBodyId::FunctionId(it) => {
-            it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
+            let loc = it.lookup(&db);
+            let tree = db.item_tree(loc.id.file_id);
+            tree.source(&db, loc.id).syntax().text_range().start()
         }
         DefWithBodyId::ConstId(it) => {
-            it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
+            let loc = it.lookup(&db);
+            let tree = db.item_tree(loc.id.file_id);
+            tree.source(&db, loc.id).syntax().text_range().start()
         }
         DefWithBodyId::StaticId(it) => {
-            it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
+            let loc = it.lookup(&db);
+            let tree = db.item_tree(loc.id.file_id);
+            tree.source(&db, loc.id).syntax().text_range().start()
         }
     });
     for def in defs {
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 8fa296137..e5ef241ca 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -271,6 +271,63 @@ fn test() {
 }
 
 #[test]
+fn infer_pattern_match_string_literal() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn test() {
+    let s: &str = "hello";
+    match s {
+        "hello" => {}
+        _ => {}
+    }
+}
+"#, true),
+    @r###"
+    10..98 '{     ...   } }': ()
+    20..21 's': &str
+    30..37 '"hello"': &str
+    43..96 'match ...     }': ()
+    49..50 's': &str
+    61..68 '"hello"': &str
+    61..68 '"hello"': &str
+    72..74 '{}': ()
+    83..84 '_': &str
+    88..90 '{}': ()
+    "###
+    );
+}
+
+#[test]
+fn infer_pattern_match_or() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn test() {
+    let s: &str = "hello";
+    match s {
+        "hello" | "world" => {}
+        _ => {}
+    }
+}
+"#, true),
+    @r###"
+    10..108 '{     ...   } }': ()
+    20..21 's': &str
+    30..37 '"hello"': &str
+    43..106 'match ...     }': ()
+    49..50 's': &str
+    61..68 '"hello"': &str
+    61..68 '"hello"': &str
+    61..78 '"hello...world"': &str
+    71..78 '"world"': &str
+    71..78 '"world"': &str
+    82..84 '{}': ()
+    93..94 '_': &str
+    98..100 '{}': ()
+    "###
+    );
+}
+
+#[test]
 fn infer_pattern_match_arr() {
     assert_snapshot!(
         infer(r#"