crates/rust-analyzer/src/global_state.rs

   1 //! The context or environment in which the language server functions. In our
   2 //! server implementation this is know as the `WorldState`.
   3 //!
   4 //! Each tick provides an immutable snapshot of the state as `WorldSnapshot`.
   5
   6 use std::{sync::Arc, time::Instant};
   7
   8 use crossbeam_channel::{unbounded, Receiver, Sender};
   9 use flycheck::FlycheckHandle;
  10 use ide::{Analysis, AnalysisHost, Cancellable, Change, FileId};
  11 use ide_db::base_db::CrateId;
  12 use lsp_types::{SemanticTokens, Url};
  13 use parking_lot::{Mutex, RwLock};
  14 use proc_macro_api::ProcMacroServer;
  15 use project_model::{CargoWorkspace, ProjectWorkspace, Target, WorkspaceBuildScripts};
  16 use rustc_hash::FxHashMap;
  17 use vfs::AnchoredPathBuf;
  18
  19 use crate::{
  20     config::Config,
  21     diagnostics::{CheckFixes, DiagnosticCollection},
  22     from_proto,
  23     line_index::{LineEndings, LineIndex},
  24     lsp_ext,
  25     main_loop::Task,
  26     mem_docs::MemDocs,
  27     op_queue::OpQueue,
  28     reload::SourceRootConfig,
  29     thread_pool::TaskPool,
  30     to_proto::url_from_abs_path,
  31     Result,
  32 };
  33
  34 // Enforces drop order
  35 pub(crate) struct Handle<H, C> {
  36     pub(crate) handle: H,
  37     pub(crate) receiver: C,
  38 }
  39
  40 pub(crate) type ReqHandler = fn(&mut GlobalState, lsp_server::Response);
  41 pub(crate) type ReqQueue = lsp_server::ReqQueue<(String, Instant), ReqHandler>;
  42
  43 /// `GlobalState` is the primary mutable state of the language server
  44 ///
  45 /// The most interesting components are `vfs`, which stores a consistent
  46 /// snapshot of the file systems, and `analysis_host`, which stores our
  47 /// incremental salsa database.
  48 ///
  49 /// Note that this struct has more than on impl in various modules!
  50 pub(crate) struct GlobalState {
  51     sender: Sender<lsp_server::Message>,
  52     req_queue: ReqQueue,
  53     pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
  54     pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
  55     pub(crate) config: Arc<Config>,
  56     pub(crate) analysis_host: AnalysisHost,
  57     pub(crate) diagnostics: DiagnosticCollection,
  58     pub(crate) mem_docs: MemDocs,
  59     pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
  60     pub(crate) shutdown_requested: bool,
  61     pub(crate) last_reported_status: Option<lsp_ext::ServerStatusParams>,
  62     pub(crate) source_root_config: SourceRootConfig,
  63     pub(crate) proc_macro_client: Option<ProcMacroServer>,
  64
  65     pub(crate) flycheck: Vec<FlycheckHandle>,
  66     pub(crate) flycheck_sender: Sender<flycheck::Message>,
  67     pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
  68
  69     pub(crate) vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
  70     pub(crate) vfs_config_version: u32,
  71     pub(crate) vfs_progress_config_version: u32,
  72     pub(crate) vfs_progress_n_total: usize,
  73     pub(crate) vfs_progress_n_done: usize,
  74
  75     /// `workspaces` field stores the data we actually use, while the `OpQueue`
  76     /// stores the result of the last fetch.
  77     ///
  78     /// If the fetch (partially) fails, we do not update the current value.
  79     ///
  80     /// The handling of build data is subtle. We fetch workspace in two phases:
  81     ///
  82     /// *First*, we run `cargo metadata`, which gives us fast results for
  83     /// initial analysis.
  84     ///
  85     /// *Second*, we run `cargo check` which runs build scripts and compiles
  86     /// proc macros.
  87     ///
  88     /// We need both for the precise analysis, but we want rust-analyzer to be
  89     /// at least partially available just after the first phase. That's because
  90     /// first phase is much faster, and is much less likely to fail.
  91     ///
  92     /// This creates a complication -- by the time the second phase completes,
  93     /// the results of the fist phase could be invalid. That is, while we run
  94     /// `cargo check`, the user edits `Cargo.toml`, we notice this, and the new
  95     /// `cargo metadata` completes before `cargo check`.
  96     ///
  97     /// An additional complication is that we want to avoid needless work. When
  98     /// the user just adds comments or whitespace to Cargo.toml, we do not want
  99     /// to invalidate any salsa caches.
 100     pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
 101     pub(crate) fetch_workspaces_queue: OpQueue<Vec<anyhow::Result<ProjectWorkspace>>>,
 102     pub(crate) fetch_build_data_queue:
 103         OpQueue<(Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
 104
 105     pub(crate) prime_caches_queue: OpQueue<()>,
 106 }
 107
 108 /// An immutable snapshot of the world's state at a point in time.
 109 pub(crate) struct GlobalStateSnapshot {
 110     pub(crate) config: Arc<Config>,
 111     pub(crate) analysis: Analysis,
 112     pub(crate) check_fixes: CheckFixes,
 113     mem_docs: MemDocs,
 114     pub(crate) semantic_tokens_cache: Arc<Mutex<FxHashMap<Url, SemanticTokens>>>,
 115     vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,
 116     pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,
 117 }
 118
 119 impl std::panic::UnwindSafe for GlobalStateSnapshot {}
 120
 121 impl GlobalState {
 122     pub(crate) fn new(sender: Sender<lsp_server::Message>, config: Config) -> GlobalState {
 123         let loader = {
 124             let (sender, receiver) = unbounded::<vfs::loader::Message>();
 125             let handle: vfs_notify::NotifyHandle =
 126                 vfs::loader::Handle::spawn(Box::new(move |msg| sender.send(msg).unwrap()));
 127             let handle = Box::new(handle) as Box<dyn vfs::loader::Handle>;
 128             Handle { handle, receiver }
 129         };
 130
 131         let task_pool = {
 132             let (sender, receiver) = unbounded();
 133             let handle = TaskPool::new(sender);
 134             Handle { handle, receiver }
 135         };
 136
 137         let analysis_host = AnalysisHost::new(config.lru_capacity());
 138         let (flycheck_sender, flycheck_receiver) = unbounded();
 139         let mut this = GlobalState {
 140             sender,
 141             req_queue: ReqQueue::default(),
 142             task_pool,
 143             loader,
 144             config: Arc::new(config.clone()),
 145             analysis_host,
 146             diagnostics: Default::default(),
 147             mem_docs: MemDocs::default(),
 148             semantic_tokens_cache: Arc::new(Default::default()),
 149             shutdown_requested: false,
 150             last_reported_status: None,
 151             source_root_config: SourceRootConfig::default(),
 152             proc_macro_client: None,
 153
 154             flycheck: Vec::new(),
 155             flycheck_sender,
 156             flycheck_receiver,
 157
 158             vfs: Arc::new(RwLock::new((vfs::Vfs::default(), FxHashMap::default()))),
 159             vfs_config_version: 0,
 160             vfs_progress_config_version: 0,
 161             vfs_progress_n_total: 0,
 162             vfs_progress_n_done: 0,
 163
 164             workspaces: Arc::new(Vec::new()),
 165             fetch_workspaces_queue: OpQueue::default(),
 166             prime_caches_queue: OpQueue::default(),
 167
 168             fetch_build_data_queue: OpQueue::default(),
 169         };
 170         // Apply any required database inputs from the config.
 171         this.update_configuration(config);
 172         this
 173     }
 174
 175     pub(crate) fn process_changes(&mut self) -> bool {
 176         let _p = profile::span("GlobalState::process_changes");
 177         let mut fs_changes = Vec::new();
 178         let mut has_fs_changes = false;
 179
 180         let change = {
 181             let mut change = Change::new();
 182             let (vfs, line_endings_map) = &mut *self.vfs.write();
 183             let changed_files = vfs.take_changes();
 184             if changed_files.is_empty() {
 185                 return false;
 186             }
 187
 188             for file in changed_files {
 189                 if file.is_created_or_deleted() {
 190                     if let Some(path) = vfs.file_path(file.file_id).as_path() {
 191                         fs_changes.push((path.to_path_buf(), file.change_kind));
 192                         has_fs_changes = true;
 193                     }
 194                 }
 195
 196                 let text = if file.exists() {
 197                     let bytes = vfs.file_contents(file.file_id).to_vec();
 198                     match String::from_utf8(bytes).ok() {
 199                         Some(text) => {
 200                             let (text, line_endings) = LineEndings::normalize(text);
 201                             line_endings_map.insert(file.file_id, line_endings);
 202                             Some(Arc::new(text))
 203                         }
 204                         None => None,
 205                     }
 206                 } else {
 207                     None
 208                 };
 209                 change.change_file(file.file_id, text);
 210             }
 211             if has_fs_changes {
 212                 let roots = self.source_root_config.partition(vfs);
 213                 change.set_roots(roots);
 214             }
 215             change
 216         };
 217
 218         self.analysis_host.apply_change(change);
 219         self.maybe_refresh(&fs_changes);
 220         true
 221     }
 222
 223     pub(crate) fn snapshot(&self) -> GlobalStateSnapshot {
 224         GlobalStateSnapshot {
 225             config: Arc::clone(&self.config),
 226             workspaces: Arc::clone(&self.workspaces),
 227             analysis: self.analysis_host.analysis(),
 228             vfs: Arc::clone(&self.vfs),
 229             check_fixes: Arc::clone(&self.diagnostics.check_fixes),
 230             mem_docs: self.mem_docs.clone(),
 231             semantic_tokens_cache: Arc::clone(&self.semantic_tokens_cache),
 232         }
 233     }
 234
 235     pub(crate) fn send_request<R: lsp_types::request::Request>(
 236         &mut self,
 237         params: R::Params,
 238         handler: ReqHandler,
 239     ) {
 240         let request = self.req_queue.outgoing.register(R::METHOD.to_string(), params, handler);
 241         self.send(request.into());
 242     }
 243     pub(crate) fn complete_request(&mut self, response: lsp_server::Response) {
 244         let handler = self.req_queue.outgoing.complete(response.id.clone());
 245         handler(self, response)
 246     }
 247
 248     pub(crate) fn send_notification<N: lsp_types::notification::Notification>(
 249         &mut self,
 250         params: N::Params,
 251     ) {
 252         let not = lsp_server::Notification::new(N::METHOD.to_string(), params);
 253         self.send(not.into());
 254     }
 255
 256     pub(crate) fn register_request(
 257         &mut self,
 258         request: &lsp_server::Request,
 259         request_received: Instant,
 260     ) {
 261         self.req_queue
 262             .incoming
 263             .register(request.id.clone(), (request.method.clone(), request_received));
 264     }
 265     pub(crate) fn respond(&mut self, response: lsp_server::Response) {
 266         if let Some((method, start)) = self.req_queue.incoming.complete(response.id.clone()) {
 267             if let Some(err) = &response.error {
 268                 if err.message.starts_with("server panicked") {
 269                     self.poke_rust_analyzer_developer(format!("{}, check the log", err.message))
 270                 }
 271             }
 272
 273             let duration = start.elapsed();
 274             tracing::info!("handled {} - ({}) in {:0.2?}", method, response.id, duration);
 275             self.send(response.into());
 276         }
 277     }
 278     pub(crate) fn cancel(&mut self, request_id: lsp_server::RequestId) {
 279         if let Some(response) = self.req_queue.incoming.cancel(request_id) {
 280             self.send(response.into());
 281         }
 282     }
 283
 284     fn send(&mut self, message: lsp_server::Message) {
 285         self.sender.send(message).unwrap()
 286     }
 287 }
 288
 289 impl Drop for GlobalState {
 290     fn drop(&mut self) {
 291         self.analysis_host.request_cancellation()
 292     }
 293 }
 294
 295 impl GlobalStateSnapshot {
 296     pub(crate) fn url_to_file_id(&self, url: &Url) -> Result<FileId> {
 297         url_to_file_id(&self.vfs.read().0, url)
 298     }
 299
 300     pub(crate) fn file_id_to_url(&self, id: FileId) -> Url {
 301         file_id_to_url(&self.vfs.read().0, id)
 302     }
 303
 304     pub(crate) fn file_line_index(&self, file_id: FileId) -> Cancellable<LineIndex> {
 305         let endings = self.vfs.read().1[&file_id];
 306         let index = self.analysis.file_line_index(file_id)?;
 307         let res = LineIndex { index, endings, encoding: self.config.offset_encoding() };
 308         Ok(res)
 309     }
 310
 311     pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> {
 312         let path = from_proto::vfs_path(url).ok()?;
 313         Some(self.mem_docs.get(&path)?.version)
 314     }
 315
 316     pub(crate) fn anchored_path(&self, path: &AnchoredPathBuf) -> Url {
 317         let mut base = self.vfs.read().0.file_path(path.anchor);
 318         base.pop();
 319         let path = base.join(&path.path).unwrap();
 320         let path = path.as_path().unwrap();
 321         url_from_abs_path(path)
 322     }
 323
 324     pub(crate) fn cargo_target_for_crate_root(
 325         &self,
 326         crate_id: CrateId,
 327     ) -> Option<(&CargoWorkspace, Target)> {
 328         let file_id = self.analysis.crate_root(crate_id).ok()?;
 329         let path = self.vfs.read().0.file_path(file_id);
 330         let path = path.as_path()?;
 331         self.workspaces.iter().find_map(|ws| match ws {
 332             ProjectWorkspace::Cargo { cargo, .. } => {
 333                 cargo.target_by_root(path).map(|it| (cargo, it))
 334             }
 335             ProjectWorkspace::Json { .. } => None,
 336             ProjectWorkspace::DetachedFiles { .. } => None,
 337         })
 338     }
 339 }
 340
 341 pub(crate) fn file_id_to_url(vfs: &vfs::Vfs, id: FileId) -> Url {
 342     let path = vfs.file_path(id);
 343     let path = path.as_path().unwrap();
 344     url_from_abs_path(path)
 345 }
 346
 347 pub(crate) fn url_to_file_id(vfs: &vfs::Vfs, url: &Url) -> Result<FileId> {
 348     let path = from_proto::vfs_path(url)?;
 349     let res = vfs.file_id(&path).ok_or_else(|| format!("file not found: {}", path))?;
 350     Ok(res)
 351 }