mirror of
https://github.com/rust-lang/rust-analyzer.git
synced 2025-10-02 22:54:58 +00:00
653 lines
26 KiB
Rust
653 lines
26 KiB
Rust
//! The context or environment in which the language server functions. In our
|
|
//! server implementation this is know as the `WorldState`.
|
|
//!
|
|
//! Each tick provides an immutable snapshot of the state as `WorldSnapshot`.
|
|
|
|
use std::{ops::Not as _, time::Instant};
|
|
|
|
use crossbeam_channel::{unbounded, Receiver, Sender};
|
|
use flycheck::{project_json, FlycheckHandle};
|
|
use hir::ChangeWithProcMacros;
|
|
use ide::{Analysis, AnalysisHost, Cancellable, FileId, SourceRootId};
|
|
use ide_db::base_db::{CrateId, ProcMacroPaths, SourceDatabaseExt};
|
|
use load_cargo::SourceRootConfig;
|
|
use lsp_types::{SemanticTokens, Url};
|
|
use nohash_hasher::IntMap;
|
|
use parking_lot::{
|
|
MappedRwLockReadGuard, Mutex, RwLock, RwLockReadGuard, RwLockUpgradableReadGuard,
|
|
RwLockWriteGuard,
|
|
};
|
|
use proc_macro_api::ProcMacroServer;
|
|
use project_model::{ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, WorkspaceBuildScripts};
|
|
use rustc_hash::{FxHashMap, FxHashSet};
|
|
use tracing::{span, trace, Level};
|
|
use triomphe::Arc;
|
|
use vfs::{AbsPathBuf, AnchoredPathBuf, ChangeKind, Vfs};
|
|
|
|
use crate::{
|
|
config::{Config, ConfigChange, ConfigErrors},
|
|
diagnostics::{CheckFixes, DiagnosticCollection},
|
|
line_index::{LineEndings, LineIndex},
|
|
lsp::{
|
|
from_proto::{self},
|
|
to_proto::url_from_abs_path,
|
|
},
|
|
lsp_ext,
|
|
main_loop::Task,
|
|
mem_docs::MemDocs,
|
|
op_queue::OpQueue,
|
|
reload,
|
|
target_spec::{CargoTargetSpec, ProjectJsonTargetSpec, TargetSpec},
|
|
task_pool::{TaskPool, TaskQueue},
|
|
};
|
|
|
|
pub(crate) struct FetchWorkspaceRequest {
|
|
pub(crate) path: Option<AbsPathBuf>,
|
|
pub(crate) force_crate_graph_reload: bool,
|
|
}
|
|
|
|
// Enforces drop order
|
|
pub(crate) struct Handle<H, C> {
|
|
pub(crate) handle: H,
|
|
pub(crate) receiver: C,
|
|
}
|
|
|
|
pub(crate) type ReqHandler = fn(&mut GlobalState, lsp_server::Response);
|
|
type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;
|
|
|
|
/// `GlobalState` is the primary mutable state of the language server
|
|
///
|
|
/// The most interesting components are `vfs`, which stores a consistent
|
|
/// snapshot of the file systems, and `analysis_host`, which stores our
|
|
/// incremental salsa database.
|
|
///
|
|
/// Note that this struct has more than one impl in various modules!
|
|
#[doc(alias = "GlobalMess")]
|
|
pub(crate) struct GlobalState {
|
|
sender: Sender<lsp_server::Message>,
|
|
req_queue: ReqQueue,
|
|
|
|
pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
|
|
pub(crate) fmt_pool: Handle<TaskPool<Task>, Receiver<Task>>,
|
|
|
|
pub(crate) config: Arc<Config>,
|
|
pub(crate) config_errors: Option<ConfigErrors>,
|
|
pub(crate) analysis_host: AnalysisHost,
|
|
pub(crate) diagnostics: DiagnosticCollection,
|
|
pub(crate) mem_docs: MemDocs,
|
|
pub(crate) source_root_config: SourceRootConfig,
|
|
/// A mapping that maps a local source root's `SourceRootId` to it parent's `SourceRootId`, if it has one.
|
|
pub(crate) local_roots_parent_map: Arc<FxHashMap<SourceRootId, SourceRootId>>,
|
|
pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
|
|
|
|
// status
|
|
pub(crate) shutdown_requested: bool,
|
|
pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,
|
|
|
|
// proc macros
|
|
pub(crate) proc_macro_clients: Arc<[anyhow::Result<ProcMacroServer>]>,
|
|
pub(crate) build_deps_changed: bool,
|
|
|
|
// Flycheck
|
|
pub(crate) flycheck: Arc<[FlycheckHandle]>,
|
|
pub(crate) flycheck_sender: Sender<flycheck::Message>,
|
|
pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
|
|
pub(crate) last_flycheck_error: Option<String>,
|
|
|
|
// Test explorer
|
|
pub(crate) test_run_session: Option<Vec<flycheck::CargoTestHandle>>,
|
|
pub(crate) test_run_sender: Sender<flycheck::CargoTestMessage>,
|
|
pub(crate) test_run_receiver: Receiver<flycheck::CargoTestMessage>,
|
|
pub(crate) test_run_remaining_jobs: usize,
|
|
|
|
// Project loading
|
|
pub(crate) discover_handle: Option<project_json::DiscoverHandle>,
|
|
pub(crate) discover_sender: Sender<project_json::DiscoverProjectMessage>,
|
|
pub(crate) discover_receiver: Receiver<project_json::DiscoverProjectMessage>,
|
|
|
|
// VFS
|
|
pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
|
|
pub(crate) vfs: Arc<RwLock<(vfs::Vfs, IntMap<FileId, LineEndings>)>>,
|
|
pub(crate) vfs_config_version: u32,
|
|
pub(crate) vfs_progress_config_version: u32,
|
|
pub(crate) vfs_progress_n_total: usize,
|
|
pub(crate) vfs_progress_n_done: usize,
|
|
|
|
/// `workspaces` field stores the data we actually use, while the `OpQueue`
|
|
/// stores the result of the last fetch.
|
|
///
|
|
/// If the fetch (partially) fails, we do not update the current value.
|
|
///
|
|
/// The handling of build data is subtle. We fetch workspace in two phases:
|
|
///
|
|
/// *First*, we run `cargo metadata`, which gives us fast results for
|
|
/// initial analysis.
|
|
///
|
|
/// *Second*, we run `cargo check` which runs build scripts and compiles
|
|
/// proc macros.
|
|
///
|
|
/// We need both for the precise analysis, but we want rust-analyzer to be
|
|
/// at least partially available just after the first phase. That's because
|
|
/// first phase is much faster, and is much less likely to fail.
|
|
///
|
|
/// This creates a complication -- by the time the second phase completes,
|
|
/// the results of the first phase could be invalid. That is, while we run
|
|
/// `cargo check`, the user edits `Cargo.toml`, we notice this, and the new
|
|
/// `cargo metadata` completes before `cargo check`.
|
|
///
|
|
/// An additional complication is that we want to avoid needless work. When
|
|
/// the user just adds comments or whitespace to Cargo.toml, we do not want
|
|
/// to invalidate any salsa caches.
|
|
pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
|
|
pub(crate) crate_graph_file_dependencies: FxHashSet<vfs::VfsPath>,
|
|
pub(crate) detached_files: FxHashSet<ManifestPath>,
|
|
|
|
// op queues
|
|
pub(crate) fetch_workspaces_queue:
|
|
OpQueue<FetchWorkspaceRequest, Option<(Vec<anyhow::Result<ProjectWorkspace>>, bool)>>,
|
|
pub(crate) fetch_build_data_queue:
|
|
OpQueue<(), (Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
|
|
pub(crate) fetch_proc_macros_queue: OpQueue<Vec<ProcMacroPaths>, bool>,
|
|
pub(crate) prime_caches_queue: OpQueue,
|
|
pub(crate) discover_workspace_queue: OpQueue,
|
|
|
|
/// A deferred task queue.
|
|
///
|
|
/// This queue is used for doing database-dependent work inside of sync
|
|
/// handlers, as accessing the database may block latency-sensitive
|
|
/// interactions and should be moved away from the main thread.
|
|
///
|
|
/// For certain features, such as [`GlobalState::handle_discover_msg`],
|
|
/// this queue should run only *after* [`GlobalState::process_changes`] has
|
|
/// been called.
|
|
pub(crate) deferred_task_queue: TaskQueue,
|
|
}
|
|
|
|
/// An immutable snapshot of the world's state at a point in time.
|
|
pub(crate) struct GlobalStateSnapshot {
|
|
pub(crate) config: Arc<Config>,
|
|
pub(crate) analysis: Analysis,
|
|
pub(crate) check_fixes: CheckFixes,
|
|
mem_docs: MemDocs,
|
|
pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
|
|
vfs: Arc<RwLock<(vfs::Vfs, IntMap<FileId, LineEndings>)>>,
|
|
pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
|
|
// used to signal semantic highlighting to fall back to syntax based highlighting until
|
|
// proc-macros have been loaded
|
|
// FIXME: Can we derive this from somewhere else?
|
|
pub(crate) proc_macros_loaded: bool,
|
|
pub(crate) flycheck: Arc<[FlycheckHandle]>,
|
|
}
|
|
|
|
impl std::panic::UnwindSafe for GlobalStateSnapshot {}
|
|
|
|
impl GlobalState {
|
|
pub(crate) fn new(sender: Sender<lsp_server::Message>, config: Config) -> GlobalState {
|
|
let loader = {
|
|
let (sender, receiver) = unbounded::<vfs::loader::Message>();
|
|
let handle: vfs_notify::NotifyHandle =
|
|
vfs::loader::Handle::spawn(Box::new(move |msg| sender.send(msg).unwrap()));
|
|
let handle = Box::new(handle) as Box<dyn vfs::loader::Handle>;
|
|
Handle { handle, receiver }
|
|
};
|
|
|
|
let task_pool = {
|
|
let (sender, receiver) = unbounded();
|
|
let handle = TaskPool::new_with_threads(sender, config.main_loop_num_threads());
|
|
Handle { handle, receiver }
|
|
};
|
|
let fmt_pool = {
|
|
let (sender, receiver) = unbounded();
|
|
let handle = TaskPool::new_with_threads(sender, 1);
|
|
Handle { handle, receiver }
|
|
};
|
|
|
|
let task_queue = {
|
|
let (sender, receiver) = unbounded();
|
|
TaskQueue { sender, receiver }
|
|
};
|
|
|
|
let mut analysis_host = AnalysisHost::new(config.lru_parse_query_capacity());
|
|
if let Some(capacities) = config.lru_query_capacities_config() {
|
|
analysis_host.update_lru_capacities(capacities);
|
|
}
|
|
let (flycheck_sender, flycheck_receiver) = unbounded();
|
|
let (test_run_sender, test_run_receiver) = unbounded();
|
|
|
|
let (discover_sender, discover_receiver) = unbounded();
|
|
|
|
let mut this = GlobalState {
|
|
sender,
|
|
req_queue: ReqQueue::default(),
|
|
task_pool,
|
|
fmt_pool,
|
|
loader,
|
|
config: Arc::new(config.clone()),
|
|
analysis_host,
|
|
diagnostics: Default::default(),
|
|
mem_docs: MemDocs::default(),
|
|
semantic_tokens_cache: Arc::new(Default::default()),
|
|
shutdown_requested: false,
|
|
last_reported_status: None,
|
|
source_root_config: SourceRootConfig::default(),
|
|
local_roots_parent_map: Arc::new(FxHashMap::default()),
|
|
config_errors: Default::default(),
|
|
|
|
proc_macro_clients: Arc::from_iter([]),
|
|
|
|
build_deps_changed: false,
|
|
|
|
flycheck: Arc::from_iter([]),
|
|
flycheck_sender,
|
|
flycheck_receiver,
|
|
last_flycheck_error: None,
|
|
|
|
test_run_session: None,
|
|
test_run_sender,
|
|
test_run_receiver,
|
|
test_run_remaining_jobs: 0,
|
|
|
|
discover_handle: None,
|
|
discover_sender,
|
|
discover_receiver,
|
|
|
|
vfs: Arc::new(RwLock::new((vfs::Vfs::default(), IntMap::default()))),
|
|
vfs_config_version: 0,
|
|
vfs_progress_config_version: 0,
|
|
vfs_progress_n_total: 0,
|
|
vfs_progress_n_done: 0,
|
|
|
|
workspaces: Arc::from(Vec::new()),
|
|
crate_graph_file_dependencies: FxHashSet::default(),
|
|
detached_files: FxHashSet::default(),
|
|
fetch_workspaces_queue: OpQueue::default(),
|
|
fetch_build_data_queue: OpQueue::default(),
|
|
fetch_proc_macros_queue: OpQueue::default(),
|
|
|
|
prime_caches_queue: OpQueue::default(),
|
|
discover_workspace_queue: OpQueue::default(),
|
|
|
|
deferred_task_queue: task_queue,
|
|
};
|
|
// Apply any required database inputs from the config.
|
|
this.update_configuration(config);
|
|
this
|
|
}
|
|
|
|
pub(crate) fn process_changes(&mut self) -> bool {
|
|
let _p = span!(Level::INFO, "GlobalState::process_changes").entered();
|
|
|
|
// We cannot directly resolve a change in a ratoml file to a format
|
|
// that can be used by the config module because config talks
|
|
// in `SourceRootId`s instead of `FileId`s and `FileId` -> `SourceRootId`
|
|
// mapping is not ready until `AnalysisHost::apply_changes` has been called.
|
|
let mut modified_ratoml_files: FxHashMap<FileId, (ChangeKind, vfs::VfsPath)> =
|
|
FxHashMap::default();
|
|
|
|
let (change, modified_rust_files, workspace_structure_change) = {
|
|
let mut change = ChangeWithProcMacros::new();
|
|
let mut guard = self.vfs.write();
|
|
let changed_files = guard.0.take_changes();
|
|
if changed_files.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
// downgrade to read lock to allow more readers while we are normalizing text
|
|
let guard = RwLockWriteGuard::downgrade_to_upgradable(guard);
|
|
let vfs: &Vfs = &guard.0;
|
|
|
|
let mut workspace_structure_change = None;
|
|
// A file was added or deleted
|
|
let mut has_structure_changes = false;
|
|
let mut bytes = vec![];
|
|
let mut modified_rust_files = vec![];
|
|
for file in changed_files.into_values() {
|
|
let vfs_path = vfs.file_path(file.file_id);
|
|
if let Some(("rust-analyzer", Some("toml"))) = vfs_path.name_and_extension() {
|
|
// Remember ids to use them after `apply_changes`
|
|
modified_ratoml_files.insert(file.file_id, (file.kind(), vfs_path.clone()));
|
|
}
|
|
|
|
if let Some(path) = vfs_path.as_path() {
|
|
has_structure_changes |= file.is_created_or_deleted();
|
|
|
|
if file.is_modified() && path.extension() == Some("rs") {
|
|
modified_rust_files.push(file.file_id);
|
|
}
|
|
|
|
let additional_files = self
|
|
.config
|
|
.discover_workspace_config()
|
|
.map(|cfg| {
|
|
cfg.files_to_watch.iter().map(String::as_str).collect::<Vec<&str>>()
|
|
})
|
|
.unwrap_or_default();
|
|
|
|
let path = path.to_path_buf();
|
|
if file.is_created_or_deleted() {
|
|
workspace_structure_change.get_or_insert((path, false)).1 |=
|
|
self.crate_graph_file_dependencies.contains(vfs_path);
|
|
} else if reload::should_refresh_for_change(
|
|
&path,
|
|
file.kind(),
|
|
&additional_files,
|
|
) {
|
|
trace!(?path, kind = ?file.kind(), "refreshing for a change");
|
|
workspace_structure_change.get_or_insert((path.clone(), false));
|
|
}
|
|
}
|
|
|
|
// Clear native diagnostics when their file gets deleted
|
|
if !file.exists() {
|
|
self.diagnostics.clear_native_for(file.file_id);
|
|
}
|
|
|
|
let text =
|
|
if let vfs::Change::Create(v, _) | vfs::Change::Modify(v, _) = file.change {
|
|
String::from_utf8(v).ok().map(|text| {
|
|
// FIXME: Consider doing normalization in the `vfs` instead? That allows
|
|
// getting rid of some locking
|
|
let (text, line_endings) = LineEndings::normalize(text);
|
|
(text, line_endings)
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
// delay `line_endings_map` changes until we are done normalizing the text
|
|
// this allows delaying the re-acquisition of the write lock
|
|
bytes.push((file.file_id, text));
|
|
}
|
|
let (vfs, line_endings_map) = &mut *RwLockUpgradableReadGuard::upgrade(guard);
|
|
bytes.into_iter().for_each(|(file_id, text)| {
|
|
let text = match text {
|
|
None => None,
|
|
Some((text, line_endings)) => {
|
|
line_endings_map.insert(file_id, line_endings);
|
|
Some(text)
|
|
}
|
|
};
|
|
change.change_file(file_id, text);
|
|
});
|
|
if has_structure_changes {
|
|
let roots = self.source_root_config.partition(vfs);
|
|
change.set_roots(roots);
|
|
}
|
|
(change, modified_rust_files, workspace_structure_change)
|
|
};
|
|
|
|
let _p = span!(Level::INFO, "GlobalState::process_changes/apply_change").entered();
|
|
self.analysis_host.apply_change(change);
|
|
if !modified_ratoml_files.is_empty()
|
|
|| !self.config.same_source_root_parent_map(&self.local_roots_parent_map)
|
|
{
|
|
let config_change = {
|
|
let user_config_path = self.config.user_config_path();
|
|
let root_ratoml_path = self.config.root_ratoml_path();
|
|
let mut change = ConfigChange::default();
|
|
let db = self.analysis_host.raw_database();
|
|
|
|
for (file_id, (_change_kind, vfs_path)) in modified_ratoml_files {
|
|
if vfs_path == *user_config_path {
|
|
change.change_user_config(Some(db.file_text(file_id)));
|
|
continue;
|
|
}
|
|
|
|
if vfs_path == *root_ratoml_path {
|
|
change.change_root_ratoml(Some(db.file_text(file_id)));
|
|
continue;
|
|
}
|
|
|
|
// If change has been made to a ratoml file that
|
|
// belongs to a non-local source root, we will ignore it.
|
|
// As it doesn't make sense a users to use external config files.
|
|
let sr_id = db.file_source_root(file_id);
|
|
let sr = db.source_root(sr_id);
|
|
if !sr.is_library {
|
|
if let Some((old_path, old_text)) = change.change_ratoml(
|
|
sr_id,
|
|
vfs_path.clone(),
|
|
Some(db.file_text(file_id)),
|
|
) {
|
|
// SourceRoot has more than 1 RATOML files. In this case lexicographically smaller wins.
|
|
if old_path < vfs_path {
|
|
span!(Level::ERROR, "Two `rust-analyzer.toml` files were found inside the same crate. {vfs_path} has no effect.");
|
|
// Put the old one back in.
|
|
change.change_ratoml(sr_id, old_path, old_text);
|
|
}
|
|
}
|
|
} else {
|
|
// Mapping to a SourceRoot should always end up in `Ok`
|
|
span!(Level::ERROR, "Mapping to SourceRootId failed.");
|
|
}
|
|
}
|
|
change.change_source_root_parent_map(self.local_roots_parent_map.clone());
|
|
change
|
|
};
|
|
|
|
let (config, e, should_update) = self.config.apply_change(config_change);
|
|
self.config_errors = e.is_empty().not().then_some(e);
|
|
|
|
if should_update {
|
|
self.update_configuration(config);
|
|
} else {
|
|
// No global or client level config was changed. So we can just naively replace config.
|
|
self.config = Arc::new(config);
|
|
}
|
|
}
|
|
|
|
{
|
|
if !matches!(&workspace_structure_change, Some((.., true))) {
|
|
_ = self
|
|
.deferred_task_queue
|
|
.sender
|
|
.send(crate::main_loop::QueuedTask::CheckProcMacroSources(modified_rust_files));
|
|
}
|
|
// FIXME: ideally we should only trigger a workspace fetch for non-library changes
|
|
// but something's going wrong with the source root business when we add a new local
|
|
// crate see https://github.com/rust-lang/rust-analyzer/issues/13029
|
|
if let Some((path, force_crate_graph_reload)) = workspace_structure_change {
|
|
let _p = span!(Level::INFO, "GlobalState::process_changes/ws_structure_change")
|
|
.entered();
|
|
|
|
self.fetch_workspaces_queue.request_op(
|
|
format!("workspace vfs file change: {path}"),
|
|
FetchWorkspaceRequest { path: Some(path.to_owned()), force_crate_graph_reload },
|
|
);
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
pub(crate) fn snapshot(&self) -> GlobalStateSnapshot {
|
|
GlobalStateSnapshot {
|
|
config: Arc::clone(&self.config),
|
|
workspaces: Arc::clone(&self.workspaces),
|
|
analysis: self.analysis_host.analysis(),
|
|
vfs: Arc::clone(&self.vfs),
|
|
check_fixes: Arc::clone(&self.diagnostics.check_fixes),
|
|
mem_docs: self.mem_docs.clone(),
|
|
semantic_tokens_cache: Arc::clone(&self.semantic_tokens_cache),
|
|
proc_macros_loaded: !self.config.expand_proc_macros()
|
|
|| *self.fetch_proc_macros_queue.last_op_result(),
|
|
flycheck: self.flycheck.clone(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn send_request<R: lsp_types::request::Request>(
|
|
&mut self,
|
|
params: R::Params,
|
|
handler: ReqHandler,
|
|
) {
|
|
let request = self.req_queue.outgoing.register(R::METHOD.to_owned(), params, handler);
|
|
self.send(request.into());
|
|
}
|
|
|
|
pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
|
|
let handler = self
|
|
.req_queue
|
|
.outgoing
|
|
.complete(response.id.clone())
|
|
.expect("received response for unknown request");
|
|
handler(self, response)
|
|
}
|
|
|
|
pub(crate) fn send_notification<N: lsp_types::notification::Notification>(
|
|
&self,
|
|
params: N::Params,
|
|
) {
|
|
let not = lsp_server::Notification::new(N::METHOD.to_owned(), params);
|
|
self.send(not.into());
|
|
}
|
|
|
|
pub(crate) fn register_request(
|
|
&mut self,
|
|
request: &lsp_server::Request,
|
|
request_received: Instant,
|
|
) {
|
|
self.req_queue
|
|
.incoming
|
|
.register(request.id.clone(), (request.method.clone(), request_received));
|
|
}
|
|
|
|
pub(crate) fn respond(&mut self, response: lsp_server::Response) {
|
|
if let Some((method, start)) = self.req_queue.incoming.complete(response.id.clone()) {
|
|
if let Some(err) = &response.error {
|
|
if err.message.starts_with("server panicked") {
|
|
self.poke_rust_analyzer_developer(format!("{}, check the log", err.message))
|
|
}
|
|
}
|
|
|
|
let duration = start.elapsed();
|
|
tracing::debug!("handled {} - ({}) in {:0.2?}", method, response.id, duration);
|
|
self.send(response.into());
|
|
}
|
|
}
|
|
|
|
pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
|
|
if let Some(response) = self.req_queue.incoming.cancel(request_id) {
|
|
self.send(response.into());
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_completed(&self, request: &lsp_server::Request) -> bool {
|
|
self.req_queue.incoming.is_completed(&request.id)
|
|
}
|
|
|
|
fn send(&self, message: lsp_server::Message) {
|
|
self.sender.send(message).unwrap()
|
|
}
|
|
}
|
|
|
|
impl Drop for GlobalState {
|
|
fn drop(&mut self) {
|
|
self.analysis_host.request_cancellation();
|
|
}
|
|
}
|
|
|
|
impl GlobalStateSnapshot {
|
|
fn vfs_read(&self) -> MappedRwLockReadGuard<'_, vfs::Vfs> {
|
|
RwLockReadGuard::map(self.vfs.read(), |(it, _)| it)
|
|
}
|
|
|
|
pub(crate) fn url_to_file_id(&self, url: &Url) -> anyhow::Result<FileId> {
|
|
url_to_file_id(&self.vfs_read(), url)
|
|
}
|
|
|
|
pub(crate) fn file_id_to_url(&self, id: FileId) -> Url {
|
|
file_id_to_url(&self.vfs_read(), id)
|
|
}
|
|
|
|
pub(crate) fn file_line_index(&self, file_id: FileId) -> Cancellable<LineIndex> {
|
|
let endings = self.vfs.read().1[&file_id];
|
|
let index = self.analysis.file_line_index(file_id)?;
|
|
let res = LineIndex { index, endings, encoding: self.config.caps().negotiated_encoding() };
|
|
Ok(res)
|
|
}
|
|
|
|
pub(crate) fn file_version(&self, file_id: FileId) -> Option<i32> {
|
|
Some(self.mem_docs.get(self.vfs_read().file_path(file_id))?.version)
|
|
}
|
|
|
|
pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> {
|
|
let path = from_proto::vfs_path(url).ok()?;
|
|
Some(self.mem_docs.get(&path)?.version)
|
|
}
|
|
|
|
pub(crate) fn anchored_path(&self, path: &AnchoredPathBuf) -> Url {
|
|
let mut base = self.vfs_read().file_path(path.anchor).clone();
|
|
base.pop();
|
|
let path = base.join(&path.path).unwrap();
|
|
let path = path.as_path().unwrap();
|
|
url_from_abs_path(path)
|
|
}
|
|
|
|
pub(crate) fn file_id_to_file_path(&self, file_id: FileId) -> vfs::VfsPath {
|
|
self.vfs_read().file_path(file_id).clone()
|
|
}
|
|
|
|
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()?;
|
|
|
|
for workspace in self.workspaces.iter() {
|
|
match &workspace.kind {
|
|
ProjectWorkspaceKind::Cargo { cargo, .. }
|
|
| ProjectWorkspaceKind::DetachedFile { cargo: Some((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(),
|
|
sysroot_root: workspace.sysroot.root().map(ToOwned::to_owned),
|
|
}));
|
|
}
|
|
ProjectWorkspaceKind::Json(project) => {
|
|
let Some(krate) = project.crate_by_root(path) else {
|
|
continue;
|
|
};
|
|
let Some(build) = krate.build else {
|
|
continue;
|
|
};
|
|
|
|
return Some(TargetSpec::ProjectJson(ProjectJsonTargetSpec {
|
|
label: build.label,
|
|
target_kind: build.target_kind,
|
|
shell_runnables: project.runnables().to_owned(),
|
|
}));
|
|
}
|
|
ProjectWorkspaceKind::DetachedFile { .. } => {}
|
|
};
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub(crate) fn file_exists(&self, file_id: FileId) -> bool {
|
|
self.vfs.read().0.exists(file_id)
|
|
}
|
|
}
|
|
|
|
pub(crate) fn file_id_to_url(vfs: &vfs::Vfs, id: FileId) -> Url {
|
|
let path = vfs.file_path(id);
|
|
let path = path.as_path().unwrap();
|
|
url_from_abs_path(path)
|
|
}
|
|
|
|
pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> anyhow::Result<FileId> {
|
|
let path = from_proto::vfs_path(url)?;
|
|
let res = vfs.file_id(&path).ok_or_else(|| anyhow::format_err!("file not found: {path}"))?;
|
|
Ok(res)
|
|
}
|