15 files changed, 385 insertions, 69 deletions
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index ee7277c04..fa524ffd9 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,6 +1,5 @@
 use std::collections::BTreeSet;
-use ast::make;
 use either::Either;
 use hir::{
    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
@@ -54,11 +53,8 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
            format!("Import `{}`", &import),
            range,
            |builder| {
-                let new_syntax = insert_use(
+                let new_syntax =
-                    &scope,
+                    insert_use(&scope, import.to_ast_path(), ctx.config.insert_use.merge);
-                    make::path_from_text(&import.to_string()),
-                    ctx.config.insert_use.merge,
-                );
                builder.replace(syntax.text_range(), new_syntax.to_string())
            },
        );
diff --git a/crates/assists/src/handlers/expand_glob_import.rs b/crates/assists/src/handlers/expand_glob_import.rs
index e14ac7f65..d1adff972 100644
--- a/crates/assists/src/handlers/expand_glob_import.rs
+++ b/crates/assists/src/handlers/expand_glob_import.rs
@@ -264,12 +264,8 @@ fn replace_ast(
    match use_trees.as_slice() {
        [name] => {
            if let Some(end_path) = name.path() {
-                let replacement = make::use_tree(
+                let replacement =
-                    make::path_from_text(&format!("{}::{}", path, end_path)),
+                    make::use_tree(make::path_concat(path, end_path), None, None, false);
-                    None,
-                    None,
-                    false,
-                );
                algo::diff(
                    &parent.either(|n| n.syntax().clone(), |n| n.syntax().clone()),
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 3ea50f375..d1eadaa99 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -12,7 +12,6 @@ use syntax::{
 use crate::{
    assist_context::AssistBuilder, utils::insert_use, AssistContext, AssistId, AssistKind, Assists,
 };
-use ast::make;
 use insert_use::ImportScope;
 // Assist: extract_struct_from_enum_variant
@@ -112,11 +111,7 @@ fn insert_import(
        let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
        let syntax = scope.as_syntax_node();
-        let new_syntax = insert_use(
+        let new_syntax = insert_use(&scope, mod_path.to_ast_path(), ctx.config.insert_use.merge);
-            &scope,
-            make::path_from_text(&mod_path.to_string()),
-            ctx.config.insert_use.merge,
-        );
        // FIXME: this will currently panic as multiple imports will have overlapping text ranges
        builder.replace(syntax.text_range(), new_syntax.to_string())
    }
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index 8ac907707..74afc123b 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,11 +1,10 @@
-use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode, TextRange};
+use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode};
 use test_utils::mark;
 use crate::{
    utils::{insert_use, ImportScope},
    AssistContext, AssistId, AssistKind, Assists,
 };
-use ast::make;
 // Assist: replace_qualified_name_with_use
 //
@@ -33,15 +32,6 @@ pub(crate) fn replace_qualified_name_with_use(
        mark::hit!(dont_import_trivial_paths);
        return None;
    }
-    let path_to_import = path.to_string();
-    let path_to_import = match path.segment()?.generic_arg_list() {
-        Some(generic_args) => {
-            let generic_args_start =
-                generic_args.syntax().text_range().start() - path.syntax().text_range().start();
-            &path_to_import[TextRange::up_to(generic_args_start)]
-        }
-        None => path_to_import.as_str(),
-    };
    let target = path.syntax().text_range();
    let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
@@ -54,14 +44,10 @@ pub(crate) fn replace_qualified_name_with_use(
            // Now that we've brought the name into scope, re-qualify all paths that could be
            // affected (that is, all paths inside the node we added the `use` to).
            let mut rewriter = SyntaxRewriter::default();
-            shorten_paths(&mut rewriter, syntax.clone(), path);
+            shorten_paths(&mut rewriter, syntax.clone(), &path);
            let rewritten_syntax = rewriter.rewrite(&syntax);
            if let Some(ref import_scope) = ImportScope::from(rewritten_syntax) {
-                let new_syntax = insert_use(
+                let new_syntax = insert_use(import_scope, path, ctx.config.insert_use.merge);
-                    import_scope,
-                    make::path_from_text(path_to_import),
-                    ctx.config.insert_use.merge,
-                );
                builder.replace(syntax.text_range(), new_syntax.to_string())
            }
        },
@@ -69,7 +55,7 @@ pub(crate) fn replace_qualified_name_with_use(
 }
 /// Adds replacements to `re` that shorten `path` in all descendants of `node`.
-fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: ast::Path) {
+fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: &ast::Path) {
    for child in node.children() {
        match_ast! {
            match child {
@@ -82,10 +68,10 @@ fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path:
                ast::Path(p) => {
                    match maybe_replace_path(rewriter, p.clone(), path.clone()) {
                        Some(()) => {},
-                        None => shorten_paths(rewriter, p.syntax().clone(), path.clone()),
+                        None => shorten_paths(rewriter, p.syntax().clone(), path),
                    }
                },
-                _ => shorten_paths(rewriter, child, path.clone()),
+                _ => shorten_paths(rewriter, child, path),
            }
        }
    }
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 734310458..209b18e78 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -13,7 +13,7 @@ use hir_expand::{
    hygiene::Hygiene,
    name::{AsName, Name},
 };
-use syntax::ast;
+use syntax::ast::{self, make};
 use crate::{
    type_ref::{TypeBound, TypeRef},
@@ -100,6 +100,26 @@ impl ModPath {
        }
        self.segments.first()
    }
+    pub fn to_ast_path(&self) -> ast::Path {
+        let mut segments = Vec::new();
+        let mut is_abs = false;
+        match self.kind {
+            PathKind::Plain => {}
+            PathKind::Super(0) => segments.push(make::path_segment_self()),
+            PathKind::Super(n) => segments.extend((0..n).map(|_| make::path_segment_super())),
+            PathKind::Crate => segments.push(make::path_segment_crate()),
+            PathKind::Abs => is_abs = true,
+            PathKind::DollarCrate(_) => (),
+        }
+        segments.extend(
+            self.segments
+                .iter()
+                .map(|segment| make::path_segment(make::name_ref(&segment.to_string()))),
+        );
+        make::path_from_segments(segments, is_abs)
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -286,10 +306,8 @@ impl Display for ModPath {
        };
        match self.kind {
            PathKind::Plain => {}
+            PathKind::Super(0) => add_segment("self")?,
            PathKind::Super(n) => {
-                if n == 0 {
-                    add_segment("self")?;
-                }
                for _ in 0..n {
                    add_segment("super")?;
                }
diff --git a/crates/ide/src/fn_references.rs b/crates/ide/src/fn_references.rs
new file mode 100644
index 000000000..1989a562b
--- /dev/null
+++ b/crates/ide/src/fn_references.rs
@@ -0,0 +1,95 @@
+//! This module implements a methods and free functions search in the specified file.
+//! We have to skip tests, so cannot reuse file_structure module.
+use hir::Semantics;
+use ide_db::RootDatabase;
+use syntax::{ast, ast::NameOwner, AstNode, SyntaxNode};
+use crate::{runnables::has_test_related_attribute, FileId, FileRange};
+pub(crate) fn find_all_methods(db: &RootDatabase, file_id: FileId) -> Vec<FileRange> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(file_id);
+    source_file.syntax().descendants().filter_map(|it| method_range(it, file_id)).collect()
+}
+fn method_range(item: SyntaxNode, file_id: FileId) -> Option<FileRange> {
+    ast::Fn::cast(item).and_then(|fn_def| {
+        if has_test_related_attribute(&fn_def) {
+            None
+        } else {
+            fn_def.name().map(|name| FileRange { file_id, range: name.syntax().text_range() })
+        }
+    })
+}
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::analysis_and_position;
+    use crate::{FileRange, TextSize};
+    use std::ops::RangeInclusive;
+    #[test]
+    fn test_find_all_methods() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+            //- /lib.rs
+            fn private_fn() {<|>}
+            pub fn pub_fn() {}
+            pub fn generic_fn<T>(arg: T) {}
+        "#,
+        );
+        let refs = analysis.find_all_methods(pos.file_id).unwrap();
+        check_result(&refs, &[3..=13, 27..=33, 47..=57]);
+    }
+    #[test]
+    fn test_find_trait_methods() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+            //- /lib.rs
+            trait Foo {
+                fn bar() {<|>}
+                fn baz() {}
+            }
+        "#,
+        );
+        let refs = analysis.find_all_methods(pos.file_id).unwrap();
+        check_result(&refs, &[19..=22, 35..=38]);
+    }
+    #[test]
+    fn test_skip_tests() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+            //- /lib.rs
+            #[test]
+            fn foo() {<|>}
+            pub fn pub_fn() {}
+            mod tests {
+                #[test]
+                fn bar() {}
+            }
+        "#,
+        );
+        let refs = analysis.find_all_methods(pos.file_id).unwrap();
+        check_result(&refs, &[28..=34]);
+    }
+    fn check_result(refs: &[FileRange], expected: &[RangeInclusive<u32>]) {
+        assert_eq!(refs.len(), expected.len());
+        for (i, item) in refs.iter().enumerate() {
+            let range = &expected[i];
+            assert_eq!(TextSize::from(*range.start()), item.range.start());
+            assert_eq!(TextSize::from(*range.end()), item.range.end());
+        }
+    }
+}
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 37171cbef..bb9f12cd3 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -14,7 +14,7 @@ use test_utils::mark;
 use crate::{
    display::{macro_label, ShortLabel, ToNav, TryToNav},
-    link_rewrite::rewrite_links,
+    link_rewrite::{remove_links, rewrite_links},
    markup::Markup,
    runnables::runnable,
    FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
@@ -26,17 +26,29 @@ pub struct HoverConfig {
    pub run: bool,
    pub debug: bool,
    pub goto_type_def: bool,
+    pub links_in_hover: bool,
 }
 impl Default for HoverConfig {
    fn default() -> Self {
-        Self { implementations: true, run: true, debug: true, goto_type_def: true }
+        Self {
+            implementations: true,
+            run: true,
+            debug: true,
+            goto_type_def: true,
+            links_in_hover: true,
+        }
    }
 }
 impl HoverConfig {
-    pub const NO_ACTIONS: Self =
+    pub const NO_ACTIONS: Self = Self {
-        Self { implementations: false, run: false, debug: false, goto_type_def: false };
+        implementations: false,
+        run: false,
+        debug: false,
+        goto_type_def: false,
+        links_in_hover: true,
+    };
    pub fn any(&self) -> bool {
        self.implementations || self.runnable() || self.goto_type_def
@@ -75,7 +87,11 @@ pub struct HoverResult {
 //
 // Shows additional information, like type of an expression or documentation for definition when "focusing" code.
 // Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.
-pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
+pub(crate) fn hover(
+    db: &RootDatabase,
+    position: FilePosition,
+    links_in_hover: bool,
+) -> Option<RangeInfo<HoverResult>> {
    let sema = Semantics::new(db);
    let file = sema.parse(position.file_id).syntax().clone();
    let token = pick_best(file.token_at_offset(position.offset))?;
@@ -93,7 +109,11 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    };
    if let Some(definition) = definition {
        if let Some(markup) = hover_for_definition(db, definition) {
-            let markup = rewrite_links(db, &markup.as_str(), &definition);
+            let markup = if links_in_hover {
+                rewrite_links(db, &markup.as_str(), &definition)
+            } else {
+                remove_links(&markup.as_str())
+            };
            res.markup = Markup::from(markup);
            if let Some(action) = show_implementations_action(db, definition) {
                res.actions.push(action);
@@ -363,12 +383,23 @@ mod tests {
    fn check_hover_no_result(ra_fixture: &str) {
        let (analysis, position) = analysis_and_position(ra_fixture);
-        assert!(analysis.hover(position).unwrap().is_none());
+        assert!(analysis.hover(position, true).unwrap().is_none());
    }
    fn check(ra_fixture: &str, expect: Expect) {
        let (analysis, position) = analysis_and_position(ra_fixture);
-        let hover = analysis.hover(position).unwrap().unwrap();
+        let hover = analysis.hover(position, true).unwrap().unwrap();
+        let content = analysis.db.file_text(position.file_id);
+        let hovered_element = &content[hover.range];
+        let actual = format!("*{}*\n{}\n", hovered_element, hover.info.markup);
+        expect.assert_eq(&actual)
+    }
+    fn check_hover_no_links(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let hover = analysis.hover(position, false).unwrap().unwrap();
        let content = analysis.db.file_text(position.file_id);
        let hovered_element = &content[hover.range];
@@ -379,7 +410,7 @@ mod tests {
    fn check_actions(ra_fixture: &str, expect: Expect) {
        let (analysis, position) = analysis_and_position(ra_fixture);
-        let hover = analysis.hover(position).unwrap().unwrap();
+        let hover = analysis.hover(position, true).unwrap().unwrap();
        expect.assert_debug_eq(&hover.info.actions)
    }
@@ -1810,6 +1841,70 @@ struct S {
    }
    #[test]
+    fn test_hover_no_links() {
+        check_hover_no_links(
+            r#"
+/// Test cases:
+/// case 1.  bare URL: https://www.example.com/
+/// case 2.  inline URL with title: [example](https://www.example.com/)
+/// case 3.  code refrence: [`Result`]
+/// case 4.  code refrence but miss footnote: [`String`]
+/// case 5.  autolink: <http://www.example.com/>
+/// case 6.  email address: <[email protected]>
+/// case 7.  refrence: [example][example]
+/// case 8.  collapsed link: [example][]
+/// case 9.  shortcut link: [example]
+/// case 10. inline without URL: [example]()
+/// case 11. refrence: [foo][foo]
+/// case 12. refrence: [foo][bar]
+/// case 13. collapsed link: [foo][]
+/// case 14. shortcut link: [foo]
+/// case 15. inline without URL: [foo]()
+/// case 16. just escaped text: \[foo]
+/// case 17. inline link: [Foo](foo::Foo)
+///
+/// [`Result`]: ../../std/result/enum.Result.html
+/// [^example]: https://www.example.com/
+pub fn fo<|>o() {}
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                test
+                ```
+                ```rust
+                pub fn foo()
+                ```
+                ---
+                Test cases:
+                case 1.  bare URL: https://www.example.com/
+                case 2.  inline URL with title: [example](https://www.example.com/)
+                case 3.  code refrence: `Result`
+                case 4.  code refrence but miss footnote: `String`
+                case 5.  autolink: http://www.example.com/
+                case 6.  email address: [email protected]
+                case 7.  refrence: example
+                case 8.  collapsed link: example
+                case 9.  shortcut link: example
+                case 10. inline without URL: example
+                case 11. refrence: foo
+                case 12. refrence: foo
+                case 13. collapsed link: foo
+                case 14. shortcut link: foo
+                case 15. inline without URL: foo
+                case 16. just escaped text: \[foo]
+                case 17. inline link: Foo
+                [^example]: https://www.example.com/
+            "#]],
+        );
+    }
+    #[test]
    fn test_hover_macro_generated_struct_fn_doc_comment() {
        mark::check!(hover_macro_generated_struct_fn_doc_comment);
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 3b97e087f..31f2bcba3 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -38,6 +38,7 @@ mod join_lines;
 mod matching_brace;
 mod parent_module;
 mod references;
+mod fn_references;
 mod runnables;
 mod status;
 mod syntax_highlighting;
@@ -369,9 +370,18 @@ impl Analysis {
        })
    }
+    /// Finds all methods and free functions for the file. Does not return tests!
+    pub fn find_all_methods(&self, file_id: FileId) -> Cancelable<Vec<FileRange>> {
+        self.with_db(|db| fn_references::find_all_methods(db, file_id))
+    }
    /// Returns a short text describing element at position.
-    pub fn hover(&self, position: FilePosition) -> Cancelable<Option<RangeInfo<HoverResult>>> {
+    pub fn hover(
-        self.with_db(|db| hover::hover(db, position))
+        &self,
+        position: FilePosition,
+        links_in_hover: bool,
+    ) -> Cancelable<Option<RangeInfo<HoverResult>>> {
+        self.with_db(|db| hover::hover(db, position, links_in_hover))
    }
    /// Computes parameter information for the given call expression.
diff --git a/crates/ide/src/link_rewrite.rs b/crates/ide/src/link_rewrite.rs
index acedea71b..107787bb9 100644
--- a/crates/ide/src/link_rewrite.rs
+++ b/crates/ide/src/link_rewrite.rs
@@ -4,7 +4,7 @@
 use hir::{Adt, Crate, HasAttrs, ModuleDef};
 use ide_db::{defs::Definition, RootDatabase};
-use pulldown_cmark::{CowStr, Event, Options, Parser, Tag};
+use pulldown_cmark::{CowStr, Event, LinkType, Options, Parser, Tag};
 use pulldown_cmark_to_cmark::{cmark_with_options, Options as CmarkOptions};
 use url::Url;
@@ -45,6 +45,41 @@ pub fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition)
    out
 }
+/// Remove all links in markdown documentation.
+pub fn remove_links(markdown: &str) -> String {
+    let mut drop_link = false;
+    let mut opts = Options::empty();
+    opts.insert(Options::ENABLE_FOOTNOTES);
+    let doc = Parser::new_with_broken_link_callback(
+        markdown,
+        opts,
+        Some(&|_, _| Some((String::new(), String::new()))),
+    );
+    let doc = doc.filter_map(move |evt| match evt {
+        Event::Start(Tag::Link(link_type, ref target, ref title)) => {
+            if link_type == LinkType::Inline && target.contains("://") {
+                Some(Event::Start(Tag::Link(link_type, target.clone(), title.clone())))
+            } else {
+                drop_link = true;
+                None
+            }
+        }
+        Event::End(_) if drop_link => {
+            drop_link = false;
+            None
+        }
+        _ => Some(evt),
+    });
+    let mut out = String::new();
+    let mut options = CmarkOptions::default();
+    options.code_block_backticks = 3;
+    cmark_with_options(doc, &mut out, None, options).ok();
+    out
+}
 fn rewrite_intra_doc_link(
    db: &RootDatabase,
    def: Definition,
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 989a63c09..cfeff40c1 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -203,7 +203,7 @@ impl TestAttr {
 ///
 /// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
 /// but it's better than not to have the runnables for the tests at all.
-fn has_test_related_attribute(fn_def: &ast::Fn) -> bool {
+pub(crate) fn has_test_related_attribute(fn_def: &ast::Fn) -> bool {
    fn_def
        .attrs()
        .filter_map(|attr| attr.path())
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 69d05aed5..42e1ad376 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -74,19 +74,18 @@ pub struct LensConfig {
    pub run: bool,
    pub debug: bool,
    pub implementations: bool,
+    pub method_refs: bool,
 }
 impl Default for LensConfig {
    fn default() -> Self {
-        Self { run: true, debug: true, implementations: true }
+        Self { run: true, debug: true, implementations: true, method_refs: false }
    }
 }
 impl LensConfig {
-    pub const NO_LENS: LensConfig = Self { run: false, debug: false, implementations: false };
    pub fn any(&self) -> bool {
-        self.implementations || self.runnable()
+        self.implementations || self.runnable() || self.references()
    }
    pub fn none(&self) -> bool {
@@ -96,6 +95,10 @@ impl LensConfig {
    pub fn runnable(&self) -> bool {
        self.run || self.debug
    }
+    pub fn references(&self) -> bool {
+        self.method_refs
+    }
 }
 #[derive(Debug, Clone)]
@@ -278,6 +281,7 @@ impl Config {
            run: data.lens_enable && data.lens_run,
            debug: data.lens_enable && data.lens_debug,
            implementations: data.lens_enable && data.lens_implementations,
+            method_refs: data.lens_enable && data.lens_methodReferences,
        };
        if !data.linkedProjects.is_empty() {
@@ -307,6 +311,7 @@ impl Config {
            run: data.hoverActions_enable && data.hoverActions_run,
            debug: data.hoverActions_enable && data.hoverActions_debug,
            goto_type_def: data.hoverActions_enable && data.hoverActions_gotoTypeDef,
+            links_in_hover: data.hoverActions_linksInHover,
        };
        log::info!("Config::update() = {:#?}", self);
@@ -451,16 +456,18 @@ config_data! {
        hoverActions_gotoTypeDef: bool     = true,
        hoverActions_implementations: bool = true,
        hoverActions_run: bool             = true,
+        hoverActions_linksInHover: bool    = true,
        inlayHints_chainingHints: bool      = true,
        inlayHints_maxLength: Option<usize> = None,
        inlayHints_parameterHints: bool     = true,
        inlayHints_typeHints: bool          = true,
-        lens_debug: bool           = true,
+        lens_debug: bool            = true,
-        lens_enable: bool          = true,
+        lens_enable: bool           = true,
-        lens_implementations: bool = true,
+        lens_implementations: bool  = true,
-        lens_run: bool             = true,
+        lens_run: bool              = true,
+        lens_methodReferences: bool = false,
        linkedProjects: Vec<ManifestOrProjectJson> = Vec::new(),
        lruCapacity: Option<usize>                 = None,
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index c0943a54d..7ac1a30f6 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -11,6 +11,7 @@ use ide::{
    FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData, NavigationTarget, Query,
    RangeInfo, Runnable, RunnableKind, SearchScope, TextEdit,
 };
+use itertools::Itertools;
 use lsp_server::ErrorCode;
 use lsp_types::{
    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
@@ -597,7 +598,7 @@ pub(crate) fn handle_hover(
 ) -> Result<Option<lsp_ext::Hover>> {
    let _p = profile::span("handle_hover");
    let position = from_proto::file_position(&snap, params.text_document_position_params)?;
-    let info = match snap.analysis.hover(position)? {
+    let info = match snap.analysis.hover(position, snap.config.hover.links_in_hover)? {
        None => return Ok(None),
        Some(info) => info,
    };
@@ -952,6 +953,22 @@ pub(crate) fn handle_code_lens(
                }),
        );
    }
+    if snap.config.lens.references() {
+        lenses.extend(snap.analysis.find_all_methods(file_id)?.into_iter().map(|it| {
+            let range = to_proto::range(&line_index, it.range);
+            let position = to_proto::position(&line_index, it.range.start());
+            let lens_params =
+                lsp_types::TextDocumentPositionParams::new(params.text_document.clone(), position);
+            CodeLens {
+                range,
+                command: None,
+                data: Some(to_value(CodeLensResolveData::References(lens_params)).unwrap()),
+            }
+        }));
+    }
    Ok(Some(lenses))
 }
@@ -959,6 +976,7 @@ pub(crate) fn handle_code_lens(
 #[serde(rename_all = "camelCase")]
 enum CodeLensResolveData {
    Impls(lsp_types::request::GotoImplementationParams),
+    References(lsp_types::TextDocumentPositionParams),
 }
 pub(crate) fn handle_code_lens_resolve(
@@ -990,6 +1008,34 @@ pub(crate) fn handle_code_lens_resolve(
            );
            Ok(CodeLens { range: code_lens.range, command: Some(cmd), data: None })
        }
+        Some(CodeLensResolveData::References(doc_position)) => {
+            let position = from_proto::file_position(&snap, doc_position.clone())?;
+            let locations = snap
+                .analysis
+                .find_all_refs(position, None)
+                .unwrap_or(None)
+                .map(|r| {
+                    r.references()
+                        .iter()
+                        .filter_map(|it| to_proto::location(&snap, it.file_range).ok())
+                        .collect_vec()
+                })
+                .unwrap_or_default();
+            let title = reference_title(locations.len());
+            let cmd = if locations.is_empty() {
+                Command { title, command: "".into(), arguments: None }
+            } else {
+                show_references_command(
+                    title,
+                    &doc_position.text_document.uri,
+                    code_lens.range.start,
+                    locations,
+                )
+            };
+            Ok(CodeLens { range: code_lens.range, command: Some(cmd), data: None })
+        }
        None => Ok(CodeLens {
            range: code_lens.range,
            command: Some(Command { title: "Error".into(), ..Default::default() }),
@@ -1248,6 +1294,14 @@ fn implementation_title(count: usize) -> String {
    }
 }
+fn reference_title(count: usize) -> String {
+    if count == 1 {
+        "1 reference".into()
+    } else {
+        format!("{} references", count)
+    }
+}
 fn show_references_command(
    title: String,
    uri: &lsp_types::Url,
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 4a0ffcbb0..3a184094c 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -28,18 +28,41 @@ pub fn assoc_item_list() -> ast::AssocItemList {
 pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment {
    ast_from_text(&format!("use {};", name_ref))
 }
 pub fn path_segment_self() -> ast::PathSegment {
    ast_from_text("use self;")
 }
+pub fn path_segment_super() -> ast::PathSegment {
+    ast_from_text("use super;")
+}
+pub fn path_segment_crate() -> ast::PathSegment {
+    ast_from_text("use crate;")
+}
 pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path {
-    path_from_text(&format!("use {}", segment))
+    ast_from_text(&format!("use {}", segment))
 }
 pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path {
-    path_from_text(&format!("{}::{}", qual, segment))
+    ast_from_text(&format!("{}::{}", qual, segment))
 }
-// FIXME: make this private
-pub fn path_from_text(text: &str) -> ast::Path {
+pub fn path_concat(first: ast::Path, second: ast::Path) -> ast::Path {
-    ast_from_text(text)
+    ast_from_text(&format!("{}::{}", first, second))
+}
+pub fn path_from_segments(
+    segments: impl IntoIterator<Item = ast::PathSegment>,
+    is_abs: bool,
+) -> ast::Path {
+    let segments = segments.into_iter().map(|it| it.syntax().clone()).join("::");
+    ast_from_text(&if is_abs {
+        format!("use ::{};", segments)
+    } else {
+        format!("use {};", segments)
+    })
 }
 pub fn glob_use_tree() -> ast::UseTree {
diff --git a/editors/code/package.json b/editors/code/package.json
index 132664926..bdd8a0c29 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -554,6 +554,11 @@
                    "type": "boolean",
                    "default": true
                },
+                "rust-analyzer.lens.methodReferences": {
+                    "markdownDescription": "Whether to show `Method References` lens. Only applies when `#rust-analyzer.lens.enable#` is set.",
+                    "type": "boolean",
+                    "default": false
+                },
                "rust-analyzer.hoverActions.enable": {
                    "description": "Whether to show HoverActions in Rust files.",
                    "type": "boolean",
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 033b04b60..848e92af9 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -138,6 +138,7 @@ export class Config {
            run: this.get<boolean>("lens.run"),
            debug: this.get<boolean>("lens.debug"),
            implementations: this.get<boolean>("lens.implementations"),
+            methodReferences: this.get<boolean>("lens.methodReferences"),
        };
    }