7 files changed, 260 insertions, 334 deletions

diff --git a/Cargo.lock b/Cargo.lock
index a808f4743..0b4d5ebe6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -40,12 +40,6 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
-
-[[package]]
-name = "autocfg"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
@@ -249,33 +243,36 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.4.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acec9a3b0b3559f15aee4f90746c4e5e293b701c0f7d3925d24e01645267b68c"
+checksum = "cced8691919c02aac3cb0a1bc2e9b73d89e832bf9a06fc579d4e71b68a2da061"
 dependencies = [
  "crossbeam-utils",
+ "maybe-uninit",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3aa945d63861bfe624b55d153a39684da1e8c0bc8fba932f7ee3a3c16cea3ca"
+checksum = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
+ "maybe-uninit",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.8.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5064ebdbf05ce3cb95e45c8b086f72263f4166b29b97f6baff7ef7fe047b55ac"
+checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
 dependencies = [
- "autocfg 0.1.7",
+ "autocfg",
  "cfg-if",
  "crossbeam-utils",
  "lazy_static",
+ "maybe-uninit",
  "memoffset",
  "scopeguard",
 ]
@@ -292,11 +289,11 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.7.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce446db02cdc3165b94ae73111e570793400d0794e46125cc4056c81cbb039f4"
+checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
 dependencies = [
- "autocfg 0.1.7",
+ "autocfg",
  "cfg-if",
  "lazy_static",
 ]
@@ -488,7 +485,7 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "076f042c5b7b98f31d205f1249267e12a6518c1481e9dae9764af19b707d2292"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg",
 ]
 
 [[package]]
@@ -623,9 +620,9 @@ checksum = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
 
 [[package]]
 name = "libc"
-version = "0.2.66"
+version = "0.2.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d515b1f41455adea1313a4a2ac8a8a477634fbae63cc6100e3aebb207ce61558"
+checksum = "eb147597cdf94ed43ab7a9038716637d2d1bf2bc571da995d0028dec06bd3018"
 
 [[package]]
 name = "linked-hash-map"
@@ -684,10 +681,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
 
 [[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+
+[[package]]
 name = "memchr"
-version = "2.3.2"
+version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53445de381a1f436797497c61d851644d0e8e88e6140f22872ad33a704933978"
+checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
 
 [[package]]
 name = "memoffset"
@@ -1531,9 +1534,9 @@ checksum = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
 
 [[package]]
 name = "syn"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af6f3550d8dff9ef7dc34d384ac6f107e5d31c8f57d9f28e0081503f547ac8f5"
+checksum = "7a0294dc449adc58bb6592fff1a23d3e5e6e235afc6a0ffca2657d19e7bbffe5"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 78d121683..eaff99fd3 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -165,7 +165,7 @@ impl CrateGraph {
         self.arena.is_empty()
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = CrateId> + 'a {
+    pub fn iter(&self) -> impl Iterator<Item = CrateId> + '_ {
         self.arena.keys().copied()
     }
 
@@ -183,10 +183,7 @@ impl CrateGraph {
         Some(crate_id)
     }
 
-    pub fn dependencies<'a>(
-        &'a self,
-        crate_id: CrateId,
-    ) -> impl Iterator<Item = &'a Dependency> + 'a {
+    pub fn dependencies(&self, crate_id: CrateId) -> impl Iterator<Item = &Dependency> {
         self.arena[&crate_id].dependencies.iter()
     }
 
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index fbe89841b..1c26a8697 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -15,7 +15,7 @@ pub use function_signature::FunctionSignature;
 pub use navigation_target::NavigationTarget;
 pub use structure::{file_structure, StructureNode};
 
-pub(crate) use navigation_target::ToNav;
+pub(crate) use navigation_target::{ToNav, TryToNav};
 pub(crate) use short_label::ShortLabel;
 
 pub(crate) fn function_label(node: &ast::FnDef) -> String {
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 096c41c81..b42cb477e 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
     TextRange,
 };
 
-use crate::{expand::original_range, FileSymbol};
+use crate::{expand::original_range, references::NameDefinition, FileSymbol};
 
 use super::short_label::ShortLabel;
 
@@ -36,6 +36,10 @@ pub(crate) trait ToNav {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget;
 }
 
+pub(crate) trait TryToNav {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget>;
+}
+
 impl NavigationTarget {
     /// When `focus_range` is specified, returns it. otherwise
     /// returns `full_range`
@@ -96,26 +100,6 @@ impl NavigationTarget {
         module.to_nav(db)
     }
 
-    pub(crate) fn from_def(
-        db: &RootDatabase,
-        module_def: hir::ModuleDef,
-    ) -> Option<NavigationTarget> {
-        let nav = match module_def {
-            hir::ModuleDef::Module(module) => module.to_nav(db),
-            hir::ModuleDef::Function(it) => it.to_nav(db),
-            hir::ModuleDef::Adt(it) => it.to_nav(db),
-            hir::ModuleDef::Const(it) => it.to_nav(db),
-            hir::ModuleDef::Static(it) => it.to_nav(db),
-            hir::ModuleDef::EnumVariant(it) => it.to_nav(db),
-            hir::ModuleDef::Trait(it) => it.to_nav(db),
-            hir::ModuleDef::TypeAlias(it) => it.to_nav(db),
-            hir::ModuleDef::BuiltinType(..) => {
-                return None;
-            }
-        };
-        Some(nav)
-    }
-
     #[cfg(test)]
     pub(crate) fn assert_match(&self, expected: &str) {
         let actual = self.debug_render();
@@ -201,6 +185,36 @@ impl ToNav for FileSymbol {
     }
 }
 
+impl TryToNav for NameDefinition {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+        match self {
+            NameDefinition::Macro(it) => Some(it.to_nav(db)),
+            NameDefinition::StructField(it) => Some(it.to_nav(db)),
+            NameDefinition::ModuleDef(it) => it.try_to_nav(db),
+            NameDefinition::SelfType(it) => Some(it.to_nav(db)),
+            NameDefinition::Local(it) => Some(it.to_nav(db)),
+            NameDefinition::TypeParam(it) => Some(it.to_nav(db)),
+        }
+    }
+}
+
+impl TryToNav for hir::ModuleDef {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+        let res = match self {
+            hir::ModuleDef::Module(it) => it.to_nav(db),
+            hir::ModuleDef::Function(it) => it.to_nav(db),
+            hir::ModuleDef::Adt(it) => it.to_nav(db),
+            hir::ModuleDef::EnumVariant(it) => it.to_nav(db),
+            hir::ModuleDef::Const(it) => it.to_nav(db),
+            hir::ModuleDef::Static(it) => it.to_nav(db),
+            hir::ModuleDef::Trait(it) => it.to_nav(db),
+            hir::ModuleDef::TypeAlias(it) => it.to_nav(db),
+            hir::ModuleDef::BuiltinType(_) => return None,
+        };
+        Some(res)
+    }
+}
+
 pub(crate) trait ToNavFromAst {}
 impl ToNavFromAst for hir::Function {}
 impl ToNavFromAst for hir::Const {}
@@ -232,15 +246,17 @@ impl ToNav for hir::Module {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.definition_source(db);
         let name = self.name(db).map(|it| it.to_string().into()).unwrap_or_default();
-        let syntax = match &src.value {
-            ModuleSource::SourceFile(node) => node.syntax(),
-            ModuleSource::Module(node) => node.syntax(),
+        let (syntax, focus) = match &src.value {
+            ModuleSource::SourceFile(node) => (node.syntax(), None),
+            ModuleSource::Module(node) => {
+                (node.syntax(), node.name().map(|it| it.syntax().text_range()))
+            }
         };
         let frange = original_range(db, src.with_value(syntax));
         NavigationTarget::from_syntax(
             frange.file_id,
             name,
-            None,
+            focus,
             frange.range,
             syntax.kind(),
             None,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index cce539e56..feff1ec3f 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,18 +1,18 @@
 //! FIXME: write short doc here
 
 use hir::{db::AstDatabase, InFile, SourceBinder};
-use ra_ide_db::{defs::NameDefinition, symbol_index, RootDatabase};
+use ra_ide_db::{symbol_index, RootDatabase};
 use ra_syntax::{
-    ast::{self, DocCommentsOwner},
+    ast::{self},
     match_ast, AstNode,
     SyntaxKind::*,
-    SyntaxNode, SyntaxToken, TokenAtOffset,
+    SyntaxToken, TokenAtOffset,
 };
 
 use crate::{
-    display::{ShortLabel, ToNav},
+    display::{ToNav, TryToNav},
     expand::descend_into_macros,
-    references::classify_name_ref,
+    references::{classify_name, classify_name_ref},
     FilePosition, NavigationTarget, RangeInfo,
 };
 
@@ -74,23 +74,12 @@ pub(crate) fn reference_definition(
     use self::ReferenceResult::*;
 
     let name_kind = classify_name_ref(sb, name_ref);
-    match name_kind {
-        Some(NameDefinition::Macro(it)) => return Exact(it.to_nav(sb.db)),
-        Some(NameDefinition::StructField(it)) => return Exact(it.to_nav(sb.db)),
-        Some(NameDefinition::TypeParam(it)) => return Exact(it.to_nav(sb.db)),
-        Some(NameDefinition::Local(it)) => return Exact(it.to_nav(sb.db)),
-        Some(NameDefinition::ModuleDef(def)) => match NavigationTarget::from_def(sb.db, def) {
-            Some(nav) => return Exact(nav),
-            None => return Approximate(vec![]),
-        },
-        Some(NameDefinition::SelfType(imp)) => {
-            // FIXME: ideally, this should point to the type in the impl, and
-            // not at the whole impl. And goto **type** definition should bring
-            // us to the actual type
-            return Exact(imp.to_nav(sb.db));
-        }
-        None => {}
-    };
+    if let Some(def) = name_kind {
+        return match def.try_to_nav(sb.db) {
+            Some(nav) => ReferenceResult::Exact(nav),
+            None => ReferenceResult::Approximate(Vec::new()),
+        };
+    }
 
     // Fallback index based approach:
     let navs = symbol_index::index_resolve(sb.db, name_ref.value)
@@ -104,119 +93,9 @@ fn name_definition(
     sb: &mut SourceBinder<RootDatabase>,
     name: InFile<&ast::Name>,
 ) -> Option<Vec<NavigationTarget>> {
-    let parent = name.value.syntax().parent()?;
-
-    if let Some(module) = ast::Module::cast(parent.clone()) {
-        if module.has_semi() {
-            let src = name.with_value(module);
-            if let Some(child_module) = sb.to_def(src) {
-                let nav = child_module.to_nav(sb.db);
-                return Some(vec![nav]);
-            }
-        }
-    }
-
-    if let Some(nav) = named_target(sb.db, name.with_value(&parent)) {
-        return Some(vec![nav]);
-    }
-
-    None
-}
-
-fn named_target(db: &RootDatabase, node: InFile<&SyntaxNode>) -> Option<NavigationTarget> {
-    match_ast! {
-        match (node.value) {
-            ast::StructDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::EnumDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::EnumVariant(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::FnDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::TypeAliasDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::ConstDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::StaticDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::TraitDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::RecordFieldDef(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::Module(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    it.short_label(),
-                ))
-            },
-            ast::MacroCall(it) => {
-                Some(NavigationTarget::from_named(
-                    db,
-                    node.with_value(&it),
-                    it.doc_comment_text(),
-                    None,
-                ))
-            },
-            _ => None,
-        }
-    }
+    let def = classify_name(sb, name)?;
+    let nav = def.try_to_nav(sb.db)?;
+    Some(vec![nav])
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 2ae97e65f..8d1c447ef 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -1,12 +1,12 @@
 //! FIXME: write short doc here
 
-use hir::{HirDisplay, SourceAnalyzer, SourceBinder};
+use hir::{Function, HirDisplay, SourceAnalyzer, SourceBinder};
 use once_cell::unsync::Lazy;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, SmolStr, SourceFile, SyntaxKind, SyntaxNode, TextRange,
+    match_ast, SmolStr, SourceFile, SyntaxNode, TextRange,
 };
 
 use crate::{FileId, FunctionSignature};
@@ -50,51 +50,53 @@ fn get_inlay_hints(
     let analyzer = Lazy::new(move || sb.analyze(hir::InFile::new(file_id.into(), node), None));
     match_ast! {
         match node {
-            ast::LetStmt(it) => {
-                if it.ascribed_type().is_some() {
-                    return None;
-                }
-                let pat = it.pat()?;
-                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
-            },
-            ast::LambdaExpr(it) => {
-                it.param_list().map(|param_list| {
-                    param_list
-                        .params()
-                        .filter(|closure_param| closure_param.ascribed_type().is_none())
-                        .filter_map(|closure_param| closure_param.pat())
-                        .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, false, max_inlay_hint_length))
-                });
-            },
-            ast::ForExpr(it) => {
-                let pat = it.pat()?;
-                get_pat_type_hints(acc, db, &analyzer, pat, false, max_inlay_hint_length);
-            },
-            ast::IfExpr(it) => {
-                let pat = it.condition()?.pat()?;
-                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
-            },
-            ast::WhileExpr(it) => {
-                let pat = it.condition()?.pat()?;
-                get_pat_type_hints(acc, db, &analyzer, pat, true, max_inlay_hint_length);
-            },
-            ast::MatchArmList(it) => {
-                it.arms()
-                    .filter_map(|match_arm| match_arm.pat())
-                    .for_each(|root_pat| get_pat_type_hints(acc, db, &analyzer, root_pat, true, max_inlay_hint_length));
-            },
             ast::CallExpr(it) => {
                 get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
             },
             ast::MethodCallExpr(it) => {
                 get_param_name_hints(acc, db, &analyzer, ast::Expr::from(it));
             },
+            ast::BindPat(it) => {
+                if should_not_display_type_hint(&it) {
+                    return None;
+                }
+                let pat = ast::Pat::from(it);
+                let ty = analyzer.type_of_pat(db, &pat)?;
+                if ty.is_unknown() {
+                    return None;
+                }
+
+                acc.push(
+                    InlayHint {
+                        range: pat.syntax().text_range(),
+                        kind: InlayKind::TypeHint,
+                        label: ty.display_truncated(db, max_inlay_hint_length).to_string().into(),
+                    }
+                );
+            },
             _ => (),
         }
     };
     Some(())
 }
 
+fn should_not_display_type_hint(bind_pat: &ast::BindPat) -> bool {
+    for node in bind_pat.syntax().ancestors() {
+        match_ast! {
+            match node {
+                ast::LetStmt(it) => {
+                    return it.ascribed_type().is_some()
+                },
+                ast::Param(it) => {
+                    return it.ascribed_type().is_some()
+                },
+                _ => (),
+            }
+        }
+    }
+    false
+}
+
 fn get_param_name_hints(
     acc: &mut Vec<InlayHint>,
     db: &RootDatabase,
@@ -105,28 +107,33 @@ fn get_param_name_hints(
         ast::Expr::CallExpr(expr) => expr.arg_list()?.args(),
         ast::Expr::MethodCallExpr(expr) => expr.arg_list()?.args(),
         _ => return None,
+    }
+    .into_iter()
+    // we need args len to determine whether to skip or not the &self parameter
+    .collect::<Vec<_>>();
+
+    let (has_self_param, fn_signature) = get_fn_signature(db, analyzer, &expr)?;
+    let parameters = if has_self_param && fn_signature.parameter_names.len() > args.len() {
+        fn_signature.parameter_names.into_iter().skip(1)
+    } else {
+        fn_signature.parameter_names.into_iter().skip(0)
     };
 
-    let mut parameters = get_fn_signature(db, analyzer, &expr)?.parameter_names.into_iter();
-
-    if let ast::Expr::MethodCallExpr(_) = &expr {
-        parameters.next();
-    };
-
-    let hints = parameters
-        .zip(args)
-        .filter_map(|(param, arg)| {
-            if arg.syntax().kind() == SyntaxKind::LITERAL && !param.is_empty() {
-                Some((arg.syntax().text_range(), param))
-            } else {
-                None
-            }
-        })
-        .map(|(range, param_name)| InlayHint {
-            range,
-            kind: InlayKind::ParameterHint,
-            label: param_name.into(),
-        });
+    let hints =
+        parameters
+            .zip(args)
+            .filter_map(|(param, arg)| {
+                if !param.is_empty() {
+                    Some((arg.syntax().text_range(), param))
+                } else {
+                    None
+                }
+            })
+            .map(|(range, param_name)| InlayHint {
+                range,
+                kind: InlayKind::ParameterHint,
+                label: param_name.into(),
+            });
 
     acc.extend(hints);
     Some(())
@@ -136,100 +143,32 @@ fn get_fn_signature(
     db: &RootDatabase,
     analyzer: &SourceAnalyzer,
     expr: &ast::Expr,
-) -> Option<FunctionSignature> {
+) -> Option<(bool, FunctionSignature)> {
     match expr {
         ast::Expr::CallExpr(expr) => {
             // FIXME: Type::as_callable is broken for closures
             let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
             match callable_def {
                 hir::CallableDef::FunctionId(it) => {
-                    let fn_def = it.into();
-                    Some(FunctionSignature::from_hir(db, fn_def))
+                    let fn_def: Function = it.into();
+                    Some((fn_def.has_self_param(db), FunctionSignature::from_hir(db, fn_def)))
                 }
-                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into()),
+                hir::CallableDef::StructId(it) => FunctionSignature::from_struct(db, it.into())
+                    .map(|signature| (false, signature)),
                 hir::CallableDef::EnumVariantId(it) => {
                     FunctionSignature::from_enum_variant(db, it.into())
+                        .map(|signature| (false, signature))
                 }
             }
         }
         ast::Expr::MethodCallExpr(expr) => {
             let fn_def = analyzer.resolve_method_call(&expr)?;
-            Some(FunctionSignature::from_hir(db, fn_def))
+            Some((fn_def.has_self_param(db), FunctionSignature::from_hir(db, fn_def)))
         }
         _ => None,
     }
 }
 
-fn get_pat_type_hints(
-    acc: &mut Vec<InlayHint>,
-    db: &RootDatabase,
-    analyzer: &SourceAnalyzer,
-    root_pat: ast::Pat,
-    skip_root_pat_hint: bool,
-    max_inlay_hint_length: Option<usize>,
-) {
-    let original_pat = &root_pat.clone();
-
-    let hints = get_leaf_pats(root_pat)
-        .into_iter()
-        .filter(|pat| !skip_root_pat_hint || pat != original_pat)
-        .filter_map(|pat| {
-            let ty = analyzer.type_of_pat(db, &pat)?;
-            if ty.is_unknown() {
-                return None;
-            }
-            Some((pat.syntax().text_range(), ty))
-        })
-        .map(|(range, pat_type)| InlayHint {
-            range,
-            kind: InlayKind::TypeHint,
-            label: pat_type.display_truncated(db, max_inlay_hint_length).to_string().into(),
-        });
-
-    acc.extend(hints);
-}
-
-fn get_leaf_pats(root_pat: ast::Pat) -> Vec<ast::Pat> {
-    let mut pats_to_process = std::collections::VecDeque::<ast::Pat>::new();
-    pats_to_process.push_back(root_pat);
-
-    let mut leaf_pats = Vec::new();
-
-    while let Some(maybe_leaf_pat) = pats_to_process.pop_front() {
-        match &maybe_leaf_pat {
-            ast::Pat::BindPat(bind_pat) => match bind_pat.pat() {
-                Some(pat) => pats_to_process.push_back(pat),
-                _ => leaf_pats.push(maybe_leaf_pat),
-            },
-            ast::Pat::OrPat(ref_pat) => pats_to_process.extend(ref_pat.pats()),
-            ast::Pat::TuplePat(tuple_pat) => pats_to_process.extend(tuple_pat.args()),
-            ast::Pat::RecordPat(record_pat) => {
-                if let Some(pat_list) = record_pat.record_field_pat_list() {
-                    pats_to_process.extend(
-                        pat_list
-                            .record_field_pats()
-                            .filter_map(|record_field_pat| {
-                                record_field_pat
-                                    .pat()
-                                    .filter(|pat| pat.syntax().kind() != SyntaxKind::BIND_PAT)
-                            })
-                            .chain(pat_list.bind_pats().map(|bind_pat| {
-                                bind_pat.pat().unwrap_or_else(|| ast::Pat::from(bind_pat))
-                            })),
-                    );
-                }
-            }
-            ast::Pat::TupleStructPat(tuple_struct_pat) => {
-                pats_to_process.extend(tuple_struct_pat.args())
-            }
-            ast::Pat::ParenPat(inner_pat) => pats_to_process.extend(inner_pat.pat()),
-            ast::Pat::RefPat(ref_pat) => pats_to_process.extend(ref_pat.pat()),
-            _ => (),
-        }
-    }
-    leaf_pats
-}
-
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
@@ -346,11 +285,6 @@ fn main() {
                 label: "i32",
             },
             InlayHint {
-                range: [584; 585),
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
                 range: [577; 578),
                 kind: TypeHint,
                 label: "f64",
@@ -361,6 +295,11 @@ fn main() {
                 label: "f64",
             },
             InlayHint {
+                range: [584; 585),
+                kind: TypeHint,
+                label: "i32",
+            },
+            InlayHint {
                 range: [627; 628),
                 kind: TypeHint,
                 label: "i32",
@@ -508,6 +447,11 @@ fn main() {
                 label: "CustomOption<Test>",
             },
             InlayHint {
+                range: [287; 291),
+                kind: TypeHint,
+                label: "&CustomOption<Test>",
+            },
+            InlayHint {
                 range: [334; 338),
                 kind: TypeHint,
                 label: "&Test",
@@ -523,10 +467,35 @@ fn main() {
                 label: "&u8",
             },
             InlayHint {
+                range: [449; 450),
+                kind: TypeHint,
+                label: "&CustomOption<u32>",
+            },
+            InlayHint {
+                range: [455; 456),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
                 range: [531; 532),
                 kind: TypeHint,
                 label: "&u32",
             },
+            InlayHint {
+                range: [538; 539),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
+                range: [618; 619),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
+                range: [675; 676),
+                kind: TypeHint,
+                label: "&u8",
+            },
         ]
         "###
         );
@@ -571,6 +540,11 @@ fn main() {
                 label: "CustomOption<Test>",
             },
             InlayHint {
+                range: [293; 297),
+                kind: TypeHint,
+                label: "&CustomOption<Test>",
+            },
+            InlayHint {
                 range: [343; 347),
                 kind: TypeHint,
                 label: "&Test",
@@ -586,10 +560,35 @@ fn main() {
                 label: "&u8",
             },
             InlayHint {
+                range: [464; 465),
+                kind: TypeHint,
+                label: "&CustomOption<u32>",
+            },
+            InlayHint {
+                range: [470; 471),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
                 range: [549; 550),
                 kind: TypeHint,
                 label: "&u32",
             },
+            InlayHint {
+                range: [556; 557),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
+                range: [639; 640),
+                kind: TypeHint,
+                label: "&u8",
+            },
+            InlayHint {
+                range: [699; 700),
+                kind: TypeHint,
+                label: "&u8",
+            },
         ]
         "###
         );
@@ -629,6 +628,11 @@ fn main() {
         assert_debug_snapshot!(analysis.inlay_hints(file_id, None).unwrap(), @r###"
         [
             InlayHint {
+                range: [272; 276),
+                kind: TypeHint,
+                label: "CustomOption<Test>",
+            },
+            InlayHint {
                 range: [311; 315),
                 kind: TypeHint,
                 label: "Test",
@@ -644,10 +648,35 @@ fn main() {
                 label: "u8",
             },
             InlayHint {
+                range: [410; 411),
+                kind: TypeHint,
+                label: "CustomOption<u32>",
+            },
+            InlayHint {
+                range: [416; 417),
+                kind: TypeHint,
+                label: "u8",
+            },
+            InlayHint {
                 range: [484; 485),
                 kind: TypeHint,
                 label: "u32",
             },
+            InlayHint {
+                range: [491; 492),
+                kind: TypeHint,
+                label: "u8",
+            },
+            InlayHint {
+                range: [563; 564),
+                kind: TypeHint,
+                label: "u8",
+            },
+            InlayHint {
+                range: [612; 613),
+                kind: TypeHint,
+                label: "u8",
+            },
         ]
         "###
         );
@@ -738,11 +767,21 @@ fn main() {
                 label: "msg",
             },
             InlayHint {
+                range: [277; 288),
+                kind: ParameterHint,
+                label: "last",
+            },
+            InlayHint {
                 range: [331; 334),
                 kind: ParameterHint,
                 label: "param",
             },
             InlayHint {
+                range: [354; 356),
+                kind: ParameterHint,
+                label: "&self",
+            },
+            InlayHint {
                 range: [358; 362),
                 kind: ParameterHint,
                 label: "param",
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 7f790a62d..aadc2dbcb 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -25,7 +25,7 @@ use ra_syntax::{
     match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, TextUnit, TokenAtOffset,
 };
 
-use crate::{display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
+use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 
 pub(crate) use self::{
     classify::{classify_name, classify_name_ref},
@@ -125,15 +125,7 @@ pub(crate) fn find_all_refs(
         };
 
     let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position, opt_name)?;
-
-    let declaration = match def {
-        NameDefinition::Macro(mac) => mac.to_nav(db),
-        NameDefinition::StructField(field) => field.to_nav(db),
-        NameDefinition::ModuleDef(def) => NavigationTarget::from_def(db, def)?,
-        NameDefinition::SelfType(imp) => imp.to_nav(db),
-        NameDefinition::Local(local) => local.to_nav(db),
-        NameDefinition::TypeParam(_) => return None,
-    };
+    let declaration = def.try_to_nav(db)?;
 
     let search_scope = {
         let base = SearchScope::for_def(&def, db);