Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

WIP

Browse source
This commit is contained in:
Antonio Scandurra 2022-01-19 19:28:41 +01:00
parent 8052f905e5
commit 10c64f527c
3 changed files with 223 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/editor/src/items.rs
View file

@ -194,7 +194,7 @@ impl ItemView for Editor {
.clone(); .clone();
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project.save_buffer_as(buffer, &abs_path, cx) project.save_buffer_as(buffer, abs_path, cx)
}) })
} }

226
crates/project/src/project.rs
View file

@ -11,14 +11,14 @@ use fuzzy::{PathMatch, PathMatchCandidate, PathMatchCandidateSet};
use gpui::{ use gpui::{
AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task,
}; };
use language::{Buffer, DiagnosticEntry, LanguageRegistry}; use language::{Buffer, DiagnosticEntry, Language, LanguageRegistry};
use lsp::DiagnosticSeverity; use lsp::{DiagnosticSeverity, LanguageServer};
use postage::{prelude::Stream, watch}; use postage::{prelude::Stream, watch};
use std::{ use std::{
path::{Path, PathBuf}, path::{Path, PathBuf},
sync::{atomic::AtomicBool, Arc}, sync::{atomic::AtomicBool, Arc},
}; };
use util::TryFutureExt as _; use util::{ResultExt, TryFutureExt as _};
pub use fs::*; pub use fs::*;
pub use worktree::*; pub use worktree::*;
@ -27,6 +27,7 @@ pub struct Project {
worktrees: Vec<ModelHandle<Worktree>>, worktrees: Vec<ModelHandle<Worktree>>,
active_entry: Option<ProjectEntry>, active_entry: Option<ProjectEntry>,
languages: Arc<LanguageRegistry>, languages: Arc<LanguageRegistry>,
language_servers: HashMap<(Arc<Path>, String), Arc<LanguageServer>>,
client: Arc<client::Client>, client: Arc<client::Client>,
user_store: ModelHandle<UserStore>, user_store: ModelHandle<UserStore>,
fs: Arc<dyn Fs>, fs: Arc<dyn Fs>,
@ -62,7 +63,6 @@ pub enum Event {
ActiveEntryChanged(Option<ProjectEntry>), ActiveEntryChanged(Option<ProjectEntry>),
WorktreeRemoved(WorktreeId), WorktreeRemoved(WorktreeId),
DiskBasedDiagnosticsStarted, DiskBasedDiagnosticsStarted,
DiskBasedDiagnosticsUpdated { worktree_id: WorktreeId },
DiskBasedDiagnosticsFinished, DiskBasedDiagnosticsFinished,
DiagnosticsUpdated(ProjectPath), DiagnosticsUpdated(ProjectPath),
} }
@ -191,6 +191,7 @@ impl Project {
user_store, user_store,
fs, fs,
pending_disk_based_diagnostics: 0, pending_disk_based_diagnostics: 0,
language_servers: Default::default(),
} }
}) })
} }
@ -283,6 +284,7 @@ impl Project {
replica_id, replica_id,
}, },
pending_disk_based_diagnostics: 0, pending_disk_based_diagnostics: 0,
language_servers: Default::default(),
}; };
for worktree in worktrees { for worktree in worktrees {
this.add_worktree(worktree, cx); this.add_worktree(worktree, cx);
@ -457,12 +459,40 @@ impl Project {
} }
pub fn open_buffer( pub fn open_buffer(
&self, &mut self,
path: ProjectPath, path: ProjectPath,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Task<Result<ModelHandle<Buffer>>> { ) -> Task<Result<ModelHandle<Buffer>>> {
if let Some(worktree) = self.worktree_for_id(path.worktree_id, cx) { if let Some(worktree) = self.worktree_for_id(path.worktree_id, cx) {
worktree.update(cx, |worktree, cx| worktree.open_buffer(path.path, cx)) let language_server = worktree
.read(cx)
.as_local()
.map(|w| w.abs_path().clone())
.and_then(|worktree_abs_path| {
let abs_path = worktree.abs_path().join(&path.path);
let language = self.languages.select_language(&abs_path).cloned();
if let Some(language) = language {
if let Some(language_server) =
self.register_language_server(worktree.abs_path(), &language, cx)
{
worktree.register_language(&language, &language_server);
}
}
});
worktree.update(cx, |worktree, cx| {
if let Some(worktree) = worktree.as_local_mut() {
let abs_path = worktree.abs_path().join(&path.path);
let language = self.languages.select_language(&abs_path).cloned();
if let Some(language) = language {
if let Some(language_server) =
self.register_language_server(worktree.abs_path(), &language, cx)
{
worktree.register_language(&language, &language_server);
}
}
}
worktree.open_buffer(path.path, cx)
})
} else { } else {
cx.spawn(|_, _| async move { Err(anyhow!("no such worktree")) }) cx.spawn(|_, _| async move { Err(anyhow!("no such worktree")) })
} }
@ -471,24 +501,194 @@ impl Project {
pub fn save_buffer_as( pub fn save_buffer_as(
&self, &self,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
abs_path: &Path, abs_path: PathBuf,
cx: &mut ModelContext<Project>, cx: &mut ModelContext<Project>,
) -> Task<Result<()>> { ) -> Task<Result<()>> {
let result = self.worktree_for_abs_path(abs_path, cx); let result = self.worktree_for_abs_path(&abs_path, cx);
cx.spawn(|_, mut cx| async move { let languages = self.languages.clone();
cx.spawn(|this, mut cx| async move {
let (worktree, path) = result.await?; let (worktree, path) = result.await?;
worktree worktree
.update(&mut cx, |worktree, cx| { .update(&mut cx, |worktree, cx| {
worktree let worktree = worktree.as_local_mut().unwrap();
.as_local() let language = languages.select_language(&abs_path);
.unwrap() if let Some(language) = language {
.save_buffer_as(buffer.clone(), path, cx) if let Some(language_server) = this.update(cx, |this, cx| {
this.register_language_server(worktree.abs_path(), language, cx)
}) {
worktree.register_language(&language, &language_server);
}
}
worktree.save_buffer_as(buffer.clone(), path, cx)
}) })
.await?; .await?;
Ok(()) Ok(())
}) })
} }
fn register_language_server(
&mut self,
worktree_abs_path: Arc<Path>,
language: &Arc<Language>,
cx: &mut ModelContext<Self>,
) -> Option<Arc<LanguageServer>> {
if let Some(server) = self
.language_servers
.get(&(worktree_abs_path.clone(), language.name().to_string()))
{
return Some(server.clone());
}
if let Some(language_server) = language
.start_server(&worktree_abs_path, cx)
.log_err()
.flatten()
{
enum DiagnosticProgress {
Updating,
Updated,
}
let disk_based_sources = language
.disk_based_diagnostic_sources()
.cloned()
.unwrap_or_default();
let disk_based_diagnostics_progress_token =
language.disk_based_diagnostics_progress_token().cloned();
let (diagnostics_tx, diagnostics_rx) = smol::channel::unbounded();
let (disk_based_diagnostics_done_tx, disk_based_diagnostics_done_rx) =
smol::channel::unbounded();
language_server
.on_notification::<lsp::notification::PublishDiagnostics, _>(move |params| {
smol::block_on(diagnostics_tx.send(params)).ok();
})
.detach();
cx.spawn_weak(|this, mut cx| {
let has_disk_based_diagnostic_progress_token =
disk_based_diagnostics_progress_token.is_some();
let disk_based_diagnostics_done_tx = disk_based_diagnostics_done_tx.clone();
async move {
while let Ok(diagnostics) = diagnostics_rx.recv().await {
if let Some(handle) = cx.read(|cx| this.upgrade(cx)) {
handle.update(&mut cx, |this, cx| {
if !has_disk_based_diagnostic_progress_token {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updating),
)
.ok();
}
this.update_diagnostics(diagnostics, &disk_based_sources, cx)
.log_err();
if !has_disk_based_diagnostic_progress_token {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updated),
)
.ok();
}
})
} else {
break;
}
}
}
})
.detach();
let mut pending_disk_based_diagnostics: i32 = 0;
language_server
.on_notification::<lsp::notification::Progress, _>(move |params| {
let token = match params.token {
lsp::NumberOrString::Number(_) => None,
lsp::NumberOrString::String(token) => Some(token),
};
if token == disk_based_diagnostics_progress_token {
match params.value {
lsp::ProgressParamsValue::WorkDone(progress) => match progress {
lsp::WorkDoneProgress::Begin(_) => {
if pending_disk_based_diagnostics == 0 {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updating),
)
.ok();
}
pending_disk_based_diagnostics += 1;
}
lsp::WorkDoneProgress::End(_) => {
pending_disk_based_diagnostics -= 1;
if pending_disk_based_diagnostics == 0 {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updated),
)
.ok();
}
}
_ => {}
},
}
}
})
.detach();
let rpc = self.client.clone();
cx.spawn_weak(|this, mut cx| async move {
while let Ok(progress) = disk_based_diagnostics_done_rx.recv().await {
if let Some(handle) = cx.read(|cx| this.upgrade(cx)) {
match progress {
DiagnosticProgress::Updating => {
let message = handle.update(&mut cx, |this, cx| {
cx.emit(Event::DiskBasedDiagnosticsUpdating);
let this = this.as_local().unwrap();
this.share.as_ref().map(|share| {
proto::DiskBasedDiagnosticsUpdating {
project_id: share.project_id,
worktree_id: this.id().to_proto(),
}
})
});
if let Some(message) = message {
rpc.send(message).await.log_err();
}
}
DiagnosticProgress::Updated => {
let message = handle.update(&mut cx, |this, cx| {
cx.emit(Event::DiskBasedDiagnosticsUpdated);
let this = this.as_local().unwrap();
this.share.as_ref().map(|share| {
proto::DiskBasedDiagnosticsUpdated {
project_id: share.project_id,
worktree_id: this.id().to_proto(),
}
})
});
if let Some(message) = message {
rpc.send(message).await.log_err();
}
}
}
} else {
break;
}
}
})
.detach();
self.language_servers.insert(
(worktree_abs_path.clone(), language.name().to_string()),
language_server.clone(),
);
Some(language_server)
} else {
None
}
}
pub fn worktree_for_abs_path( pub fn worktree_for_abs_path(
&self, &self,
abs_path: &Path, abs_path: &Path,

165
crates/project/src/worktree.rs
View file

@ -1156,157 +1156,10 @@ impl LocalWorktree {
pub fn register_language( pub fn register_language(
&mut self, &mut self,
language: &Arc<Language>, language: &Arc<Language>,
cx: &mut ModelContext<Worktree>, language_server: &Arc<LanguageServer>,
) -> Option<Arc<LanguageServer>> { ) {
if let Some(server) = self.language_servers.get(language.name()) { self.language_servers
return Some(server.clone()); .insert(language.name().to_string(), language_server.clone());
}
if let Some(language_server) = language
.start_server(self.abs_path(), cx)
.log_err()
.flatten()
{
enum DiagnosticProgress {
Updating,
Updated,
}
let disk_based_sources = language
.disk_based_diagnostic_sources()
.cloned()
.unwrap_or_default();
let disk_based_diagnostics_progress_token =
language.disk_based_diagnostics_progress_token().cloned();
let (diagnostics_tx, diagnostics_rx) = smol::channel::unbounded();
let (disk_based_diagnostics_done_tx, disk_based_diagnostics_done_rx) =
smol::channel::unbounded();
language_server
.on_notification::<lsp::notification::PublishDiagnostics, _>(move |params| {
smol::block_on(diagnostics_tx.send(params)).ok();
})
.detach();
cx.spawn_weak(|this, mut cx| {
let has_disk_based_diagnostic_progress_token =
disk_based_diagnostics_progress_token.is_some();
let disk_based_diagnostics_done_tx = disk_based_diagnostics_done_tx.clone();
async move {
while let Ok(diagnostics) = diagnostics_rx.recv().await {
if let Some(handle) = cx.read(|cx| this.upgrade(cx)) {
handle.update(&mut cx, |this, cx| {
if !has_disk_based_diagnostic_progress_token {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updating),
)
.ok();
}
this.update_diagnostics(diagnostics, &disk_based_sources, cx)
.log_err();
if !has_disk_based_diagnostic_progress_token {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updated),
)
.ok();
}
})
} else {
break;
}
}
}
})
.detach();
let mut pending_disk_based_diagnostics: i32 = 0;
language_server
.on_notification::<lsp::notification::Progress, _>(move |params| {
let token = match params.token {
lsp::NumberOrString::Number(_) => None,
lsp::NumberOrString::String(token) => Some(token),
};
if token == disk_based_diagnostics_progress_token {
match params.value {
lsp::ProgressParamsValue::WorkDone(progress) => match progress {
lsp::WorkDoneProgress::Begin(_) => {
if pending_disk_based_diagnostics == 0 {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updating),
)
.ok();
}
pending_disk_based_diagnostics += 1;
}
lsp::WorkDoneProgress::End(_) => {
pending_disk_based_diagnostics -= 1;
if pending_disk_based_diagnostics == 0 {
smol::block_on(
disk_based_diagnostics_done_tx
.send(DiagnosticProgress::Updated),
)
.ok();
}
}
_ => {}
},
}
}
})
.detach();
let rpc = self.client.clone();
cx.spawn_weak(|this, mut cx| async move {
while let Ok(progress) = disk_based_diagnostics_done_rx.recv().await {
if let Some(handle) = cx.read(|cx| this.upgrade(cx)) {
match progress {
DiagnosticProgress::Updating => {
let message = handle.update(&mut cx, |this, cx| {
cx.emit(Event::DiskBasedDiagnosticsUpdating);
let this = this.as_local().unwrap();
this.share.as_ref().map(|share| {
proto::DiskBasedDiagnosticsUpdating {
project_id: share.project_id,
worktree_id: this.id().to_proto(),
}
})
});
if let Some(message) = message {
rpc.send(message).await.log_err();
}
}
DiagnosticProgress::Updated => {
let message = handle.update(&mut cx, |this, cx| {
cx.emit(Event::DiskBasedDiagnosticsUpdated);
let this = this.as_local().unwrap();
this.share.as_ref().map(|share| {
proto::DiskBasedDiagnosticsUpdated {
project_id: share.project_id,
worktree_id: this.id().to_proto(),
}
})
});
if let Some(message) = message {
rpc.send(message).await.log_err();
}
}
}
} else {
break;
}
}
})
.detach();
self.language_servers
.insert(language.name().to_string(), language_server.clone());
Some(language_server.clone())
} else {
None
}
} }
fn get_open_buffer( fn get_open_buffer(
@ -1342,7 +1195,7 @@ impl LocalWorktree {
.update(&mut cx, |t, cx| t.as_local().unwrap().load(&path, cx)) .update(&mut cx, |t, cx| t.as_local().unwrap().load(&path, cx))
.await?; .await?;
let (diagnostics, language, language_server) = this.update(&mut cx, |this, cx| { let (diagnostics, language, language_server) = this.update(&mut cx, |this, _| {
let this = this.as_local_mut().unwrap(); let this = this.as_local_mut().unwrap();
let diagnostics = this.diagnostics.get(&path).cloned(); let diagnostics = this.diagnostics.get(&path).cloned();
let language = this let language = this
@ -1351,7 +1204,7 @@ impl LocalWorktree {
.cloned(); .cloned();
let server = language let server = language
.as_ref() .as_ref()
.and_then(|language| this.register_language(language, cx)); .and_then(|language| this.language_servers.get(language.name()).cloned());
(diagnostics, language, server) (diagnostics, language, server)
}); });
@ -1522,7 +1375,7 @@ impl LocalWorktree {
} }
}); });
let (language, language_server) = this.update(&mut cx, |worktree, cx| { let (language, language_server) = this.update(&mut cx, |worktree, _| {
let worktree = worktree.as_local_mut().unwrap(); let worktree = worktree.as_local_mut().unwrap();
let language = worktree let language = worktree
.language_registry() .language_registry()
@ -1530,7 +1383,7 @@ impl LocalWorktree {
.cloned(); .cloned();
let language_server = language let language_server = language
.as_ref() .as_ref()
.and_then(|language| worktree.register_language(language, cx)); .and_then(|language| worktree.language_servers.get(language.name()).cloned());
(language, language_server.clone()) (language, language_server.clone())
}); });
@ -3277,7 +3130,7 @@ mod tests {
use client::test::{FakeHttpClient, FakeServer}; use client::test::{FakeHttpClient, FakeServer};
use fs::RealFs; use fs::RealFs;
use gpui::test::subscribe; use gpui::test::subscribe;
use language::{tree_sitter_rust, DiagnosticEntry, LanguageServerConfig}; use language::{tree_sitter_rust, DiagnosticEntry, Language, LanguageServerConfig};
use language::{Diagnostic, LanguageConfig}; use language::{Diagnostic, LanguageConfig};
use lsp::Url; use lsp::Url;
use rand::prelude::*; use rand::prelude::*;