clean

Author: Song Gao

crates/ide/src/lib.rs

@@ -527,15 +527,6 @@ impl Analysis {
         self.with_db(|db| test_items::test_runnables_in_file(db, file_id))
     }
 
-    pub fn test_runnables_in_db(
-        &self,
-        // workspaces: &Arc<Vec<ProjectWorkspace>>,
-    ) -> Cancellable<Vec<Runnable>> {
-        self.with_db(|db| test_items::test_runnables_in_db(db
-            // , workspaces
-        ))
-    }
-
     /// Returns the set of tests for the given file position.
     pub fn related_tests(
         &self,

crates/ide/src/test_items.rs

@@ -1,63 +1,17 @@
-use std::path::PathBuf;
-
 /// This mod is mainly to support vscode native test extension
 /// please reference: https://code.visualstudio.com/api/extension-guides/testing
 // It's a pretty rough implementation for now, reuse a lot of logic from runnable.
 use ide_db::{
-    base_db::{FileId, SourceDatabaseExt},
+    base_db::{FileId},
     RootDatabase,
 };
-use itertools::Itertools;
 
 use crate::{runnables::runnables, Runnable, RunnableKind};
 
 pub(crate) fn test_runnables_in_file(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     return test_runnables_in_file_iter(db, file_id).collect();
 }
 
-// TODO: delete related code, for we want to do it lazily
-pub(crate) fn test_runnables_in_db(
-    db: &RootDatabase,
-    // _workspaces: &Arc<Vec<ProjectWorkspace>>,
-) -> Vec<Runnable> {
-    // use workspace seems to be better, but why there are multi roots?
-    // let workspace_roots = workspaces
-    //     .iter()
-    //     .map(|workspace| workspace.workspace_definition_path().unwrap())
-    //     .collect::<FxHashSet<_>>();
-    // use cargo home path as a trick
-    let cargo_home_path = home::cargo_home();
-    let rustup_home_path = home::rustup_home();
-    let crate_graph = ide_db::search::SearchScope::crate_graph(db);
-    let tests = crate_graph
-        .into_iter()
-        // skip the module if it's dependency
-        .filter(|(file_id, _)| match (&cargo_home_path, &rustup_home_path) {
-            (Ok(cargo_home_path), Ok(rustup_home_path)) => {
-                let root_id = db.file_source_root(file_id.clone());
-                let source_root = db.source_root(root_id);
-                let file_path: PathBuf = source_root
-                    .path_for_file(file_id)
-                    .unwrap()
-                    .as_path()
-                    .unwrap()
-                    .to_path_buf()
-                    .into();
-                // dependency file will be downloaed to `cargo_home_path`
-                // only find test runnables in user files
-                let is_not_dependency = !file_path.starts_with(cargo_home_path);
-                let is_not_standard_lib = !file_path.starts_with(rustup_home_path);
-                return is_not_dependency && is_not_standard_lib;
-            }
-            // If neighther is not existed, search all.
-            // Or assert as `never!`?
-            _ => return true,
-        })
-        .flat_map(|(file_id, _)| test_runnables_in_file_iter(db, file_id))
-        .collect_vec();
-    return tests;
-}
-
 fn test_runnables_in_file_iter(
     db: &RootDatabase,
     file_id: FileId,

crates/rust-analyzer/src/handlers.rs

@@ -805,23 +805,6 @@ pub(crate) fn handle_runnables(
     Ok(res)
 }
 
-pub(crate) fn handle_test_runnables_in_db(
-    snap: GlobalStateSnapshot,
-    _: (),
-) -> Result<Vec<lsp_ext::TestInfo2>> {
-    let _p = profile::span("handle_test_runnables_in_db");
-    let test_runnables = snap.analysis.test_runnables_in_db(
-        // &snap.workspaces
-    )?;
-    let mut res = Vec::new();
-    for runnable in test_runnables {
-        let runnable = to_proto::test_info_2(&snap, runnable)?;
-        res.push(runnable);
-    }
-
-    Ok(res)
-}
-
 pub(crate) fn handle_cargo_workspaces(
     snap: GlobalStateSnapshot,
     _: (),
@@ -844,15 +827,15 @@ pub(crate) fn handle_cargo_workspaces(
 pub(crate) fn handle_test_runnables_in_file(
     snap: GlobalStateSnapshot,
     params: lsp_ext::TestRunnablesInFileParams,
-) -> Result<Vec<lsp_ext::TestInfo2>> {
+) -> Result<Vec<lsp_ext::Runnable>> {
     let _p = profile::span("handle_test_runnables_in_file");
 
     let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
     let test_runnables = snap.analysis.test_runnables_in_file(file_id)?;
 
     let mut res = Vec::new();
     for runnable in test_runnables {
-        let runnable = to_proto::test_info_2(&snap, runnable)?;
+        let runnable = to_proto::runnable(&snap, runnable)?;
         res.push(runnable);
     }
 

crates/rust-analyzer/src/lsp_ext.rs

@@ -296,14 +296,6 @@ pub struct TestInfo {
     pub runnable: Runnable,
 }
 
-pub enum TestRunnablesInDb {}
-
-impl Request for TestRunnablesInDb {
-    type Params = ();
-    type Result = Vec<TestInfo2>;
-    const METHOD: &'static str = "rust-analyzer/testRunnablesInDb";
-}
-
 pub enum CargoWorkspaces{}
 
 impl Request for CargoWorkspaces{
@@ -316,18 +308,10 @@ pub enum TestRunnablesInFile {}
 
 impl Request for TestRunnablesInFile {
     type Params = TestRunnablesInFileParams;
-    type Result = Vec<TestInfo2>;
+    type Result = Vec<Runnable>;
     const METHOD: &'static str = "rust-analyzer/testRunnablesInFile";
 }
 
-// Need to find a more proper data struct for test explorer
-// The main purpose of such struct is to reuse `Runnable` related resource
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TestInfo2 {
-    pub runnable: Runnable,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct InlayHintsParams {

crates/rust-analyzer/src/main_loop.rs

@@ -673,7 +673,6 @@ impl GlobalState {
             .on::<lsp_ext::Runnables>(handlers::handle_runnables)
             .on::<lsp_ext::CargoWorkspaces>(handlers:: handle_cargo_workspaces)
             .on::<lsp_ext::TestRunnablesInFile>(handlers::handle_test_runnables_in_file)
-            .on::<lsp_ext::TestRunnablesInDb>(handlers::handle_test_runnables_in_db)
             .on::<lsp_ext::RelatedTests>(handlers::handle_related_tests)
             .on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)
             .on::<lsp_ext::CodeActionResolveRequest>(handlers::handle_code_action_resolve)

crates/rust-analyzer/src/to_proto.rs

@@ -1174,15 +1174,6 @@ pub(crate) fn runnable(
     })
 }
 
-pub(crate) fn test_info_2(
-    snap: &GlobalStateSnapshot,
-    runnable_data: Runnable,
-) -> Cancellable<lsp_ext::TestInfo2> {
-    let lsp_runnable_data = runnable(snap, runnable_data)?;
-
-    Ok(lsp_ext::TestInfo2 { runnable: lsp_runnable_data })
-}
-
 pub(crate) fn code_lens(
     acc: &mut Vec<lsp_types::CodeLens>,
     snap: &GlobalStateSnapshot,

editors/code/src/lsp_ext.ts

@@ -68,14 +68,12 @@ export const viewMir = new lc.RequestType<lc.TextDocumentPositionParams, string,
 export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(
     "rust-analyzer/viewItemTree"
 );
-export const testRunnablesInDb = new lc.RequestType0<TestInfo2[], void>(
-    "rust-analyzer/testRunnablesInDb"
-);
+
 export const cargoWorkspaces = new lc.RequestType0<CargoMetadata[], void>(
     "rust-analyzer/cargoWorkspaces"
 );
 
-export const testRunnablesInFile = new lc.RequestType<TestRunnablesInFileParams, TestInfo2[], void>(
+export const testRunnablesInFile = new lc.RequestType<TestRunnablesInFileParams, Runnable[], void>(
     "rust-analyzer/testRunnablesInFile"
 );
 export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };
@@ -89,9 +87,7 @@ export type ExpandedMacro = {
     expansion: string;
 };
 export type TestInfo = { runnable: Runnable };
-export type TestInfo2 = {
-    runnable: Runnable;
-};
+
 export type SyntaxTreeParams = {
     textDocument: lc.TextDocumentIdentifier;
     range: lc.Range | null;

editors/code/src/test_explorer/discover_and_update.ts

@@ -164,7 +164,7 @@ async function updateModelByChangeOfFile(uri: vscode.Uri) {
     }
 
     // Ensure parent is created in the test-model-tree
-    const runnables = testInfos.map(it => new RunnableFacde(it.runnable));
+    const runnables = testInfos.map(it => new RunnableFacde(it));
 
     const testModuelRunnables = runnables.filter(it =>
         it.testKind === NodeKind.TestModule)
@@ -262,7 +262,7 @@ async function fetchChildrenForTestModuleNode(testModuleNode: TestModuleNode) {
 
     assert(!!rawRunnables);
 
-    const runnables = rawRunnables.map(it => new RunnableFacde(it.runnable));
+    const runnables = rawRunnables.map(it => new RunnableFacde(it));
 
     await updateModelByRunnables(testModuleNode, runnables);
 }