refactor: Split out a target_spec_for_crate helper

Author: Wilfred

crates/rust-analyzer/src/global_state.rs

@@ -18,7 +18,7 @@ use parking_lot::{
     RwLockWriteGuard,
 };
 use proc_macro_api::ProcMacroServer;
-use project_model::{CargoWorkspace, ProjectWorkspace, Target, WorkspaceBuildScripts};
+use project_model::{ProjectWorkspace, WorkspaceBuildScripts};
 use rustc_hash::{FxHashMap, FxHashSet};
 use triomphe::Arc;
 use vfs::{AnchoredPathBuf, ChangedFile, Vfs};
@@ -33,6 +33,7 @@ use crate::{
     mem_docs::MemDocs,
     op_queue::OpQueue,
     reload,
+    target_spec::{CargoTargetSpec, TargetSpec},
     task_pool::{TaskPool, TaskQueue},
 };
 
@@ -500,20 +501,38 @@ impl GlobalStateSnapshot {
         self.vfs_read().file_path(file_id).clone()
     }
 
-    pub(crate) fn cargo_target_for_crate_root(
-        &self,
-        crate_id: CrateId,
-    ) -> Option<(&CargoWorkspace, Target)> {
+    pub(crate) fn target_spec_for_crate(&self, crate_id: CrateId) -> Option<TargetSpec> {
         let file_id = self.analysis.crate_root(crate_id).ok()?;
         let path = self.vfs_read().file_path(file_id).clone();
         let path = path.as_path()?;
-        self.workspaces.iter().find_map(|ws| match ws {
-            ProjectWorkspace::Cargo { cargo, .. } => {
-                cargo.target_by_root(path).map(|it| (cargo, it))
+
+        for workspace in self.workspaces.iter() {
+            match workspace {
+                ProjectWorkspace::Cargo { cargo, .. } => {
+                    let Some(target_idx) = cargo.target_by_root(path) else {
+                        continue;
+                    };
+
+                    let target_data = &cargo[target_idx];
+                    let package_data = &cargo[target_data.package];
+
+                    return Some(TargetSpec::Cargo(CargoTargetSpec {
+                        workspace_root: cargo.workspace_root().to_path_buf(),
+                        cargo_toml: package_data.manifest.clone(),
+                        crate_id,
+                        package: cargo.package_flag(package_data),
+                        target: target_data.name.clone(),
+                        target_kind: target_data.kind,
+                        required_features: target_data.required_features.clone(),
+                        features: package_data.features.keys().cloned().collect(),
+                    }));
+                }
+                ProjectWorkspace::Json { .. } => {}
+                ProjectWorkspace::DetachedFiles { .. } => {}
             }
-            ProjectWorkspace::Json { .. } => None,
-            ProjectWorkspace::DetachedFiles { .. } => None,
-        })
+        }
+
+        None
     }
 
     pub(crate) fn file_exists(&self, file_id: FileId) -> bool {

crates/rust-analyzer/src/lsp/to_proto.rs

@@ -1546,12 +1546,8 @@ pub(crate) fn test_item(
         id: test_item.id,
         label: test_item.label,
         kind: match test_item.kind {
-            ide::TestItemKind::Crate(id) => 'b: {
-                let Some((cargo_ws, target)) = snap.cargo_target_for_crate_root(id) else {
-                    break 'b lsp_ext::TestItemKind::Package;
-                };
-                let target = &cargo_ws[target];
-                match target.kind {
+            ide::TestItemKind::Crate(id) => match snap.target_spec_for_crate(id) {
+                Some(target_spec) => match target_spec.target_kind() {
                     project_model::TargetKind::Bin
                     | project_model::TargetKind::Lib { .. }
                     | project_model::TargetKind::Example
@@ -1560,8 +1556,9 @@ pub(crate) fn test_item(
                     project_model::TargetKind::Test | project_model::TargetKind::Bench => {
                         lsp_ext::TestItemKind::Test
                     }
-                }
-            }
+                },
+                None => lsp_ext::TestItemKind::Package,
+            },
             ide::TestItemKind::Module => lsp_ext::TestItemKind::Module,
             ide::TestItemKind::Function => lsp_ext::TestItemKind::Test,
         },

crates/rust-analyzer/src/target_spec.rs

@@ -29,27 +29,7 @@ impl TargetSpec {
             _ => return Ok(None),
         };
 
-        match global_state_snapshot.cargo_target_for_crate_root(crate_id) {
-            Some((cargo_ws, target)) => {
-                let target_data = &cargo_ws[target];
-                let package_data = &cargo_ws[target_data.package];
-                let res = CargoTargetSpec {
-                    workspace_root: cargo_ws.workspace_root().to_path_buf(),
-                    cargo_toml: package_data.manifest.clone(),
-                    crate_id,
-                    package: cargo_ws.package_flag(package_data),
-                    target: target_data.name.clone(),
-                    target_kind: target_data.kind,
-                    required_features: target_data.required_features.clone(),
-                    features: package_data.features.keys().cloned().collect(),
-                };
-                Ok(Some(TargetSpec::Cargo(res)))
-            }
-            None => {
-                tracing::debug!(?crate_id, "no target found");
-                Ok(None)
-            }
-        }
+        Ok(global_state_snapshot.target_spec_for_crate(crate_id))
     }
 
     pub(crate) fn target_kind(&self) -> TargetKind {