Add path support for marking test modules

Author: farodin91

crates/ra_analysis/src/imp.rs

@@ -201,8 +201,23 @@ impl AnalysisImpl {
         let source_root = self.db.file_source_root(file_id);
         self.db.module_tree(source_root)
     }
+    pub(crate) fn module_path(&self, file_id: FileId) -> Cancelable<String> {
+        let mut current_file_id = file_id;
+        let mut path = "".to_string();
+        loop {
+            if let Some((file_id, file_symbol)) = self.parent_module(current_file_id)?.first() {
+                path = format!("{}::{}", file_symbol.name, path);
+                current_file_id = *file_id;
+            } else {
+                break;
+            }
+        }
+
+        Ok(path.to_string())
+    }
     pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let module_tree = self.module_tree(file_id)?;
+        println!("{:?}", module_tree);
 
         let res = module_tree.modules_for_file(file_id)
             .into_iter()

crates/ra_analysis/src/lib.rs

@@ -263,6 +263,9 @@ impl Analysis {
     pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp.parent_module(file_id)
     }
+    pub fn module_path(&self, file_id: FileId) -> Cancelable<String> {
+        self.imp.module_path(file_id)
+    }
     pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
         self.imp.crate_for(file_id)
     }
@@ -271,7 +274,8 @@ impl Analysis {
     }
     pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
         let file = self.imp.file_syntax(file_id);
-        Ok(runnables::runnables(&file))
+        let path = self.imp.module_path(file_id)?;
+        Ok(runnables::runnables(&file, &path))
     }
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
         let file = self.imp.file_syntax(file_id);

crates/ra_analysis/src/runnables.rs

@@ -18,14 +18,14 @@ pub enum RunnableKind {
     Bin,
 }
 
-pub fn runnables(file: &File) -> Vec<Runnable> {
+pub fn runnables(file: &File, module_path: &str) -> Vec<Runnable> {
     file.syntax()
         .descendants()
-        .filter_map(runnable)
+        .filter_map(|i| runnable(i, module_path))
         .collect()
 }
 
-fn runnable<'a>(item: SyntaxNodeRef<'a>) -> Option<Runnable> {
+fn runnable<'a>(item: SyntaxNodeRef<'a>, module_path: &str) -> Option<Runnable> {
     if let Some(f) = ast::FnDef::cast(item) {
         let name = f.name()?.text();
         let kind = if name == "main" {
@@ -48,10 +48,25 @@ fn runnable<'a>(item: SyntaxNodeRef<'a>) -> Option<Runnable> {
             .map(ast::ModuleItem::syntax)
             .filter_map(ast::FnDef::cast)
             .any(|f| f.has_atom_attr("test")) {
+                let mut current_module = m;
+                let mut path = String::new();
+                loop {
+                    if let Some(item_list) = current_module.syntax().parent().and_then(ast::ItemList::cast) {
+                        if let Some(m) = item_list.syntax().parent().and_then(ast::Module::cast){
+                            path = format!("{}::{}", m.name().unwrap().text(), path);
+                            current_module = m;
+                        } else {
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            
             Some(Runnable {
                 range: m.syntax().range(),
                 kind: RunnableKind::TestMod {
-                    path: name.to_string()
+                    path: format!("{}::{}{}", module_path, path, name),
                 }
             })
         }else {
@@ -81,7 +96,7 @@ fn test_foo() {}
 fn test_foo() {}
 "#,
         );
-        let runnables = runnables(&file);
+        let runnables = runnables(&file, "");
         assert_eq_dbg(
             r#"[Runnable { range: [1; 13), kind: Bin },
                 Runnable { range: [15; 39), kind: Test { name: "test_foo" } },
@@ -100,14 +115,56 @@ mod test_mod {
 }
 "#,
         );
-        let runnables = runnables(&file);
+        let runnables = runnables(&file, "parent");
         assert_eq_dbg(
-            r#"[Runnable { range: [1; 51), kind: TestMod { path: "test_mod" } },
+            r#"[Runnable { range: [1; 51), kind: TestMod { path: "parent::test_mod" } },
                 Runnable { range: [20; 49), kind: Test { name: "test_foo1" } }]"#,
             &runnables,
         )
     }
 
+    #[test]
+    fn test_runnables_one_depth_layer_module() {
+        let file = File::parse(
+            r#"
+mod foo {
+    mod test_mod {
+        #[test]
+        fn test_foo1() {}
+    }
+}
+"#,
+        );
+        let runnables = runnables(&file, "parent");
+        assert_eq_dbg(
+            r#"[Runnable { range: [15; 77), kind: TestMod { path: "parent::foo::test_mod" } },
+                Runnable { range: [38; 71), kind: Test { name: "test_foo1" } }]"#,
+            &runnables,
+        )
+    }
+
+    #[test]
+    fn test_runnables_multiple_depth_module() {
+        let file = File::parse(
+            r#"
+mod foo {
+    mod bar {
+        mod test_mod {
+            #[test]
+            fn test_foo1() {}
+        }
+    }
+}
+"#,
+        );
+        let runnables = runnables(&file, "parent");
+        assert_eq_dbg(
+            r#"[Runnable { range: [33; 107), kind: TestMod { path: "parent::foo::bar::test_mod" } },
+                Runnable { range: [60; 97), kind: Test { name: "test_foo1" } }]"#,
+            &runnables,
+        )
+    }
+
     #[test]
     fn test_runnables_no_test_function_in_module() {
         let file = File::parse(
@@ -117,7 +174,7 @@ mod test_mod {
 }
 "#,
         );
-        let runnables = runnables(&file);
+        let runnables = runnables(&file, "");
         assert_eq_dbg(
             r#"[]"#,
             &runnables,

crates/ra_analysis/tests/tests.rs

@@ -123,6 +123,26 @@ fn test_resolve_parent_module() {
     );
 }
 
+#[test]
+fn test_path_one_layer() {
+    let snap = analysis(&[("/lib.rs", "mod foo;"), ("/foo/mod.rs", "mod bla;"), ("/foo/bla.rs", "")]);
+    let symbols = snap.module_path(FileId(3)).unwrap();
+    assert_eq!(
+        "foo::bla::",
+        &symbols,
+    );
+}
+
+#[test]
+fn test_path_two_layer() {
+    let snap = analysis(&[("/lib.rs", "mod foo;"), ("/foo/mod.rs", "mod bla;"), ("/foo/bla/mod.rs", "mod more;"), ("/foo/bla/more.rs", "")]);
+    let symbols = snap.module_path(FileId(4)).unwrap();
+    assert_eq!(
+        "foo::bla::more::",
+        &symbols,
+    );
+}
+
 #[test]
 fn test_resolve_crate_root() {
     let mut host = analysis_host(&[("/lib.rs", "mod foo;"), ("/foo.rs", "")]);