rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

fix: correctly update diagnostics when files are opened and closed

Browse Source 
Basically, this tracks the changes to `subscriptions` we use when
issuing a publish_diagnostics.
This commit is contained in:
Aleksey Kladov
2021-07-26 21:18:22 +03:00
parent 410679285b
commit 891867b1f1
2 changed files with 78 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
crates/rust-analyzer/src/main_loop.rs
View File

@@ -406,25 +406,49 @@ impl GlobalState {
}
let state_changed = self.process_changes();
let memdocs_added_or_removed = self.mem_docs.take_changes();
if self.is_quiescent() && !was_quiescent {
for flycheck in &self.flycheck {
flycheck.update();
}
}
if self.is_quiescent() && (!was_quiescent || state_changed) {
self.update_file_notifications_on_threadpool();
// Refresh semantic tokens if the client supports it.
if self.config.semantic_tokens_refresh() {
self.semantic_tokens_cache.lock().clear();
self.send_request::<lsp_types::request::SemanticTokensRefesh>((), |_, _| ());
if self.is_quiescent() {
if !was_quiescent {
for flycheck in &self.flycheck {
flycheck.update();
}
}
// Refresh code lens if the client supports it.
if self.config.code_lens_refresh() {
self.send_request::<lsp_types::request::CodeLensRefresh>((), |_, _| ());
if !was_quiescent || state_changed {
// Ensure that only one cache priming task can run at a time
self.prime_caches_queue.request_op();
if self.prime_caches_queue.should_start_op() {
self.task_pool.handle.spawn_with_sender({
let snap = self.snapshot();
move |sender| {
let cb = |progress| {
sender.send(Task::PrimeCaches(progress)).unwrap();
};
match snap.analysis.prime_caches(cb) {
Ok(()) => (),
Err(_canceled) => (),
}
}
});
}
// Refresh semantic tokens if the client supports it.
if self.config.semantic_tokens_refresh() {
self.semantic_tokens_cache.lock().clear();
self.send_request::<lsp_types::request::SemanticTokensRefesh>((), |_, _| ());
}
// Refresh code lens if the client supports it.
if self.config.code_lens_refresh() {
self.send_request::<lsp_types::request::CodeLensRefresh>((), |_, _| ());
}
}
if !was_quiescent || state_changed || memdocs_added_or_removed {
if self.config.publish_diagnostics() {
self.update_diagnostics()
}
}
}
@@ -586,42 +610,32 @@ impl GlobalState {
{
log::error!("duplicate DidOpenTextDocument: {}", path)
}
let changed = this
.vfs
this.vfs
.write()
.0
.set_file_contents(path, Some(params.text_document.text.into_bytes()));
// If the VFS contents are unchanged, update diagnostics, since `handle_event`
// won't see any changes. This avoids missing diagnostics when opening a file.
//
// If the file *was* changed, `handle_event` will already recompute and send
// diagnostics. We can't do it here, since the *current* file contents might be
// unset in salsa, since the VFS change hasn't been applied to the database yet.
if !changed {
this.maybe_update_diagnostics();
}
}
Ok(())
})?
.on::<lsp_types::notification::DidChangeTextDocument>(|this, params| {
if let Ok(path) = from_proto::vfs_path(&params.text_document.uri) {
let doc = match this.mem_docs.get_mut(&path) {
Some(doc) => doc,
match this.mem_docs.get_mut(&path) {
Some(doc) => {
// The version passed in DidChangeTextDocument is the version after all edits are applied
// so we should apply it before the vfs is notified.
doc.version = params.text_document.version;
}
None => {
log::error!("expected DidChangeTextDocument: {}", path);
return Ok(());
}
};
let vfs = &mut this.vfs.write().0;
let file_id = vfs.file_id(&path).unwrap();
let mut text = String::from_utf8(vfs.file_contents(file_id).to_vec()).unwrap();
apply_document_changes(&mut text, params.content_changes);
// The version passed in DidChangeTextDocument is the version after all edits are applied
// so we should apply it before the vfs is notified.
doc.version = params.text_document.version;
vfs.set_file_contents(path.clone(), Some(text.into_bytes()));
}
Ok(())
@@ -696,27 +710,8 @@ impl GlobalState {
.finish();
Ok(())
}
fn update_file_notifications_on_threadpool(&mut self) {
self.maybe_update_diagnostics();
// Ensure that only one cache priming task can run at a time
self.prime_caches_queue.request_op();
if self.prime_caches_queue.should_start_op() {
self.task_pool.handle.spawn_with_sender({
let snap = self.snapshot();
move |sender| {
let cb = |progress| {
sender.send(Task::PrimeCaches(progress)).unwrap();
};
match snap.analysis.prime_caches(cb) {
Ok(()) => (),
Err(_canceled) => (),
}
}
});
}
}
fn maybe_update_diagnostics(&mut self) {
fn update_diagnostics(&mut self) {
let subscriptions = self
.mem_docs
.iter()
@@ -724,25 +719,24 @@ impl GlobalState {
.collect::<Vec<_>>();
log::trace!("updating notifications for {:?}", subscriptions);
if self.config.publish_diagnostics() {
let snapshot = self.snapshot();
self.task_pool.handle.spawn(move || {
let diagnostics = subscriptions
.into_iter()
.filter_map(|file_id| {
handlers::publish_diagnostics(&snapshot, file_id)
.map_err(|err| {
if !is_cancelled(&*err) {
log::error!("failed to compute diagnostics: {:?}", err);
}
()
})
.ok()
.map(|diags| (file_id, diags))
})
.collect::<Vec<_>>();
Task::Diagnostics(diagnostics)
})
}
let snapshot = self.snapshot();
self.task_pool.handle.spawn(move || {
let diagnostics = subscriptions
.into_iter()
.filter_map(|file_id| {
handlers::publish_diagnostics(&snapshot, file_id)
.map_err(|err| {
if !is_cancelled(&*err) {
log::error!("failed to compute diagnostics: {:?}", err);
}
()
})
.ok()
.map(|diags| (file_id, diags))
})
.collect::<Vec<_>>();
Task::Diagnostics(diagnostics)
})
}
}