1 files changed, 108 insertions, 5 deletions

diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index 38637c19c..131b8f307 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::Semantics;
+use hir::{AsAssocItem, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
@@ -9,6 +9,7 @@ use ra_syntax::{
 };
 
 use crate::FileId;
+use ast::DocCommentsOwner;
 use std::fmt::Display;
 
 #[derive(Debug)]
@@ -37,6 +38,7 @@ pub enum RunnableKind {
     Test { test_id: TestId, attr: TestAttr },
     TestMod { path: String },
     Bench { test_id: TestId },
+    DocTest { test_id: TestId },
     Bin,
 }
 
@@ -63,14 +65,36 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, fn_def: ast::FnDef) -> Option<Run
         RunnableKind::Bin
     } else {
         let test_id = if let Some(module) = sema.to_def(&fn_def).map(|def| def.module(sema.db)) {
-            let path = module
+            let def = sema.to_def(&fn_def)?;
+            let impl_trait_name =
+                def.as_assoc_item(sema.db).and_then(|assoc_item| {
+                    match assoc_item.container(sema.db) {
+                        hir::AssocItemContainer::Trait(trait_item) => {
+                            Some(trait_item.name(sema.db).to_string())
+                        }
+                        hir::AssocItemContainer::ImplDef(impl_def) => impl_def
+                            .target_ty(sema.db)
+                            .as_adt()
+                            .map(|adt| adt.name(sema.db).to_string()),
+                    }
+                });
+
+            let path_iter = module
                 .path_to_root(sema.db)
                 .into_iter()
                 .rev()
                 .filter_map(|it| it.name(sema.db))
-                .map(|name| name.to_string())
-                .chain(std::iter::once(name_string))
-                .join("::");
+                .map(|name| name.to_string());
+
+            let path = if let Some(impl_trait_name) = impl_trait_name {
+                path_iter
+                    .chain(std::iter::once(impl_trait_name))
+                    .chain(std::iter::once(name_string))
+                    .join("::")
+            } else {
+                path_iter.chain(std::iter::once(name_string)).join("::")
+            };
+
             TestId::Path(path)
         } else {
             TestId::Name(name_string)
@@ -81,6 +105,8 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, fn_def: ast::FnDef) -> Option<Run
             RunnableKind::Test { test_id, attr }
         } else if fn_def.has_atom_attr("bench") {
             RunnableKind::Bench { test_id }
+        } else if has_doc_test(&fn_def) {
+            RunnableKind::DocTest { test_id }
         } else {
             return None;
         }
@@ -117,6 +143,10 @@ fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
         .any(|attribute_text| attribute_text.contains("test"))
 }
 
+fn has_doc_test(fn_def: &ast::FnDef) -> bool {
+    fn_def.doc_comment_text().map_or(false, |comment| comment.contains("```"))
+}
+
 fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
     let has_test_function = module
         .item_list()?
@@ -195,6 +225,79 @@ mod tests {
     }
 
     #[test]
+    fn test_runnables_doc_test() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+
+        /// ```
+        /// let x = 5;
+        /// ```
+        fn foo() {}
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot!(&runnables,
+        @r###"
+        [
+            Runnable {
+                range: 1..21,
+                kind: Bin,
+            },
+            Runnable {
+                range: 22..64,
+                kind: DocTest {
+                    test_id: Path(
+                        "foo",
+                    ),
+                },
+            },
+        ]
+        "###
+                );
+    }
+
+    #[test]
+    fn test_runnables_doc_test_in_impl() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+
+        struct Data;
+        impl Data {
+            /// ```
+            /// let x = 5;
+            /// ```
+            fn foo() {}
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot!(&runnables,
+        @r###"
+        [
+            Runnable {
+                range: 1..21,
+                kind: Bin,
+            },
+            Runnable {
+                range: 51..105,
+                kind: DocTest {
+                    test_id: Path(
+                        "Data::foo",
+                    ),
+                },
+            },
+        ]
+        "###
+                );
+    }
+
+    #[test]
     fn test_runnables_module() {
         let (analysis, pos) = analysis_and_position(
             r#"