use crossbeam_channel::{unbounded, Receiver, Sender};
use flycheck::FlycheckHandle;
-use ide::{Analysis, AnalysisHost, Change, FileId};
-use ide_db::base_db::{CrateId, VfsPath};
+use ide::{Analysis, AnalysisHost, Cancellable, Change, FileId};
+use ide_db::base_db::CrateId;
use lsp_types::{SemanticTokens, Url};
use parking_lot::{Mutex, RwLock};
-use project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
+use project_model::{
+ CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target, WorkspaceBuildScripts,
+};
use rustc_hash::FxHashMap;
+use vfs::AnchoredPathBuf;
use crate::{
config::Config,
diagnostics::{CheckFixes, DiagnosticCollection},
- document::DocumentData,
from_proto,
- line_endings::LineEndings,
+ line_index::{LineEndings, LineIndex},
+ lsp_ext,
main_loop::Task,
+ mem_docs::MemDocs,
+ op_queue::OpQueue,
reload::SourceRootConfig,
request_metrics::{LatestRequests, RequestMetrics},
thread_pool::TaskPool,
Result,
};
-#[derive(Eq, PartialEq, Copy, Clone)]
-pub(crate) enum Status {
- Loading,
- Ready,
- Invalid,
- NeedsReload,
-}
-
-impl Default for Status {
- fn default() -> Self {
- Status::Loading
- }
-}
-
// Enforces drop order
pub(crate) struct Handle<H, C> {
pub(crate) handle: H,
req_queue: ReqQueue,
pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
- pub(crate) flycheck: Vec<FlycheckHandle>,
- pub(crate) flycheck_sender: Sender<flycheck::Message>,
- pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
- pub(crate) config: Config,
+ pub(crate) config: Arc<Config>,
pub(crate) analysis_host: AnalysisHost,
pub(crate) diagnostics: DiagnosticCollection,
- pub(crate) mem_docs: FxHashMap<VfsPath, DocumentData>,
+ pub(crate) mem_docs: MemDocs,
pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
- pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
pub(crate) shutdown_requested: bool,
- pub(crate) status: Status,
+ pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,
pub(crate) source_root_config: SourceRootConfig,
pub(crate) proc_macro_client: Option<ProcMacroClient>,
+
+ pub(crate) flycheck: Vec<FlycheckHandle>,
+ pub(crate) flycheck_sender: Sender<flycheck::Message>,
+ pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
+
+ pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<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 fist 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) fetch_workspaces_queue: OpQueue<Vec<anyhow::Result<ProjectWorkspace>>>,
+ pub(crate) fetch_build_data_queue:
+ OpQueue<(Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
+
+ pub(crate) prime_caches_queue: OpQueue<()>,
+
latest_requests: Arc<RwLock<LatestRequests>>,
}
/// An immutable snapshot of the world's state at a point in time.
pub(crate) struct GlobalStateSnapshot {
- pub(crate) config: Config,
+ pub(crate) config: Arc<Config>,
pub(crate) analysis: Analysis,
pub(crate) check_fixes: CheckFixes,
pub(crate) latest_requests: Arc<RwLock<LatestRequests>>,
- mem_docs: FxHashMap<VfsPath, DocumentData>,
+ mem_docs: MemDocs,
pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
Handle { handle, receiver }
};
- let analysis_host = AnalysisHost::new(config.lru_capacity);
+ let analysis_host = AnalysisHost::new(config.lru_capacity());
let (flycheck_sender, flycheck_receiver) = unbounded();
- GlobalState {
+ let mut this = GlobalState {
sender,
req_queue: ReqQueue::default(),
task_pool,
loader,
- flycheck: Vec::new(),
- flycheck_sender,
- flycheck_receiver,
- config,
+ config: Arc::new(config.clone()),
analysis_host,
diagnostics: Default::default(),
- mem_docs: FxHashMap::default(),
+ mem_docs: MemDocs::default(),
semantic_tokens_cache: Arc::new(Default::default()),
- vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
shutdown_requested: false,
- status: Status::default(),
+ last_reported_status: None,
source_root_config: SourceRootConfig::default(),
proc_macro_client: None,
+
+ flycheck: Vec::new(),
+ flycheck_sender,
+ flycheck_receiver,
+
+ vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
+ vfs_config_version: 0,
+ vfs_progress_config_version: 0,
+ vfs_progress_n_total: 0,
+ vfs_progress_n_done: 0,
+
workspaces: Arc::new(Vec::new()),
+ fetch_workspaces_queue: OpQueue::default(),
+ prime_caches_queue: OpQueue::default(),
+
+ fetch_build_data_queue: OpQueue::default(),
latest_requests: Default::default(),
- }
+ };
+ // Apply any required database inputs from the config.
+ this.update_configuration(config);
+ this
}
pub(crate) fn process_changes(&mut self) -> bool {
change.change_file(file.file_id, text);
}
if has_fs_changes {
- let roots = self.source_root_config.partition(&vfs);
+ let roots = self.source_root_config.partition(vfs);
change.set_roots(roots);
}
change
pub(crate) fn snapshot(&self) -> GlobalStateSnapshot {
GlobalStateSnapshot {
- config: self.config.clone(),
+ config: Arc::clone(&self.config),
workspaces: Arc::clone(&self.workspaces),
analysis: self.analysis_host.analysis(),
vfs: Arc::clone(&self.vfs),
file_id_to_url(&self.vfs.read().0, id)
}
- pub(crate) fn file_line_endings(&self, id: FileId) -> LineEndings {
- self.vfs.read().1[&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.offset_encoding() };
+ Ok(res)
}
pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> {
- let path = from_proto::vfs_path(&url).ok()?;
+ let path = from_proto::vfs_path(url).ok()?;
Some(self.mem_docs.get(&path)?.version)
}
- pub(crate) fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
- let mut base = self.vfs.read().0.file_path(file_id);
+ pub(crate) fn anchored_path(&self, path: &AnchoredPathBuf) -> Url {
+ let mut base = self.vfs.read().0.file_path(path.anchor);
base.pop();
- let path = base.join(path).unwrap();
+ let path = base.join(&path.path).unwrap();
let path = path.as_path().unwrap();
- url_from_abs_path(&path)
+ url_from_abs_path(path)
}
pub(crate) fn cargo_target_for_crate_root(
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))
+ cargo.target_by_root(path).map(|it| (cargo, it))
}
ProjectWorkspace::Json { .. } => None,
+ ProjectWorkspace::DetachedFiles { .. } => None,
})
}
}
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)
+ url_from_abs_path(path)
}
pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> Result<FileId> {