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

Switch LspAdapter to struct and revert some async/await

Browse source
This commit is contained in:
Isaac Clayton 2022-07-06 13:09:14 +02:00
parent 0872e9b1a7
commit 4f016d5fc4
2 changed files with 125 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

136
crates/language/src/language.rs
View file

@ -7,6 +7,7 @@ pub mod proto;
mod tests; mod tests;
use anyhow::{anyhow, Context, Result}; use anyhow::{anyhow, Context, Result};
use async_trait::async_trait;
use client::http::HttpClient; use client::http::HttpClient;
use collections::HashMap; use collections::HashMap;
use futures::{ use futures::{
@ -63,38 +64,103 @@ pub trait ToLspPosition {
#[derive(Clone, Debug, PartialEq, Eq, Hash)] #[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LanguageServerName(pub Arc<str>); pub struct LanguageServerName(pub Arc<str>);
use async_trait::async_trait; /// Represents a Language Server, with certain cached sync properties.
/// Uses [`LspAdapterTrait`] under the hood, but calls all 'static' methods
/// once at startup, and caches the results.
pub struct LspAdapter {
pub name: LanguageServerName,
pub server_args: Vec<String>,
pub initialization_options: Option<Value>,
pub disk_based_diagnostic_sources: Vec<String>,
pub disk_based_diagnostics_progress_token: Option<String>,
pub id_for_language: Option<String>,
pub adapter: Box<dyn LspAdapterTrait>,
}
// pub struct LspAdapter { impl LspAdapter {
// name: LanguageServerName, pub async fn new(adapter: impl LspAdapterTrait) -> Arc<Self> {
// adapter: Arc<dyn LspAdapter>, let adapter = Box::new(adapter);
// } let name = adapter.name().await;
let server_args = adapter.server_args().await;
let initialization_options = adapter.initialization_options().await;
let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources().await;
let disk_based_diagnostics_progress_token =
adapter.disk_based_diagnostics_progress_token().await;
let id_for_language = adapter.id_for_language(name.0.as_ref()).await;
// impl LspAdapter { Arc::new(LspAdapter {
// async fn new(adapter: Arc<dyn LspAdapter>) -> Self { name,
// let name = adapter.name().await; server_args,
initialization_options,
disk_based_diagnostic_sources,
disk_based_diagnostics_progress_token,
id_for_language,
adapter,
})
}
// LspAdapter { name, adapter } pub async fn fetch_latest_server_version(
// } &self,
http: Arc<dyn HttpClient>,
) -> Result<Box<dyn 'static + Send + Any>> {
self.adapter.fetch_latest_server_version(http).await
}
// fn name(&self) -> LanguageServerName { pub async fn fetch_server_binary(
// self.name &self,
// } version: Box<dyn 'static + Send + Any>,
// } http: Arc<dyn HttpClient>,
container_dir: PathBuf,
) -> Result<PathBuf> {
self.adapter
.fetch_server_binary(version, http, container_dir)
.await
}
pub async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<PathBuf> {
self.adapter.cached_server_binary(container_dir).await
}
pub async fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
self.adapter.process_diagnostics(params).await
}
pub async fn label_for_completion(
&self,
completion_item: &lsp::CompletionItem,
language: &Language,
) -> Option<CodeLabel> {
self.adapter
.label_for_completion(completion_item, language)
.await
}
pub async fn label_for_symbol(
&self,
name: &str,
kind: lsp::SymbolKind,
language: &Language,
) -> Option<CodeLabel> {
self.adapter.label_for_symbol(name, kind, language).await
}
}
#[async_trait] #[async_trait]
pub trait LspAdapter: 'static + Send + Sync { pub trait LspAdapterTrait: 'static + Send + Sync {
async fn name(&self) -> LanguageServerName; async fn name(&self) -> LanguageServerName;
async fn fetch_latest_server_version( async fn fetch_latest_server_version(
&self, &self,
http: Arc<dyn HttpClient>, http: Arc<dyn HttpClient>,
) -> Result<Box<dyn 'static + Send + Any>>; ) -> Result<Box<dyn 'static + Send + Any>>;
async fn fetch_server_binary( async fn fetch_server_binary(
&self, &self,
version: Box<dyn 'static + Send + Any>, version: Box<dyn 'static + Send + Any>,
http: Arc<dyn HttpClient>, http: Arc<dyn HttpClient>,
container_dir: PathBuf, container_dir: PathBuf,
) -> Result<PathBuf>; ) -> Result<PathBuf>;
async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<PathBuf>; async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<PathBuf>;
async fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {} async fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
@ -189,7 +255,9 @@ fn deserialize_regex<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Regex>, D
} }
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
pub struct FakeLspAdapter { pub type FakeLspAdapter = Arc<FakeLspAdapterInner>;
pub struct FakeLspAdapterInner {
pub name: &'static str, pub name: &'static str,
pub capabilities: lsp::ServerCapabilities, pub capabilities: lsp::ServerCapabilities,
pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>, pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
@ -208,12 +276,12 @@ pub struct BracketPair {
pub struct Language { pub struct Language {
pub(crate) config: LanguageConfig, pub(crate) config: LanguageConfig,
pub(crate) grammar: Option<Arc<Grammar>>, pub(crate) grammar: Option<Arc<Grammar>>,
pub(crate) adapter: Option<Arc<dyn LspAdapter>>, pub(crate) adapter: Option<Arc<LspAdapter>>,
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
fake_adapter: Option<( fake_adapter: Option<(
mpsc::UnboundedSender<lsp::FakeLanguageServer>, mpsc::UnboundedSender<lsp::FakeLanguageServer>,
Arc<FakeLspAdapter>, FakeLspAdapter,
)>, )>,
} }
@ -373,7 +441,7 @@ impl LanguageRegistry {
let server_binary_path = this let server_binary_path = this
.lsp_binary_paths .lsp_binary_paths
.lock() .lock()
.entry(adapter.name().await) .entry(adapter.name.clone())
.or_insert_with(|| { .or_insert_with(|| {
get_server_binary_path( get_server_binary_path(
adapter.clone(), adapter.clone(),
@ -390,7 +458,7 @@ impl LanguageRegistry {
.map_err(|e| anyhow!(e)); .map_err(|e| anyhow!(e));
let server_binary_path = server_binary_path.await?; let server_binary_path = server_binary_path.await?;
let server_args = adapter.server_args().await; let server_args = &adapter.server_args;
let server = lsp::LanguageServer::new( let server = lsp::LanguageServer::new(
server_id, server_id,
&server_binary_path, &server_binary_path,
@ -410,13 +478,13 @@ impl LanguageRegistry {
} }
async fn get_server_binary_path( async fn get_server_binary_path(
adapter: Arc<dyn LspAdapter>, adapter: Arc<LspAdapter>,
language: Arc<Language>, language: Arc<Language>,
http_client: Arc<dyn HttpClient>, http_client: Arc<dyn HttpClient>,
download_dir: Arc<Path>, download_dir: Arc<Path>,
statuses: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>, statuses: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>,
) -> Result<PathBuf> { ) -> Result<PathBuf> {
let container_dir = download_dir.join(adapter.name().await.0.as_ref()); let container_dir = download_dir.join(adapter.name.0.as_ref());
if !container_dir.exists() { if !container_dir.exists() {
smol::fs::create_dir_all(&container_dir) smol::fs::create_dir_all(&container_dir)
.await .await
@ -452,7 +520,7 @@ async fn get_server_binary_path(
} }
async fn fetch_latest_server_binary_path( async fn fetch_latest_server_binary_path(
adapter: Arc<dyn LspAdapter>, adapter: Arc<LspAdapter>,
language: Arc<Language>, language: Arc<Language>,
http_client: Arc<dyn HttpClient>, http_client: Arc<dyn HttpClient>,
container_dir: &Path, container_dir: &Path,
@ -501,7 +569,7 @@ impl Language {
} }
} }
pub fn lsp_adapter(&self) -> Option<Arc<dyn LspAdapter>> { pub fn lsp_adapter(&self) -> Option<Arc<LspAdapter>> {
self.adapter.clone() self.adapter.clone()
} }
@ -533,7 +601,7 @@ impl Language {
Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap() Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap()
} }
pub fn with_lsp_adapter(mut self, lsp_adapter: Arc<dyn LspAdapter>) -> Self { pub fn with_lsp_adapter(mut self, lsp_adapter: Arc<LspAdapter>) -> Self {
self.adapter = Some(lsp_adapter); self.adapter = Some(lsp_adapter);
self self
} }
@ -544,8 +612,8 @@ impl Language {
fake_lsp_adapter: FakeLspAdapter, fake_lsp_adapter: FakeLspAdapter,
) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> { ) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
let (servers_tx, servers_rx) = mpsc::unbounded(); let (servers_tx, servers_rx) = mpsc::unbounded();
let adapter = Arc::new(fake_lsp_adapter); self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
self.fake_adapter = Some((servers_tx, adapter.clone())); let adapter = smol::block_on(LspAdapter::new(fake_lsp_adapter));
self.adapter = Some(adapter); self.adapter = Some(adapter);
servers_rx servers_rx
} }
@ -558,16 +626,16 @@ impl Language {
self.config.line_comment.as_deref() self.config.line_comment.as_deref()
} }
pub async fn disk_based_diagnostic_sources(&self) -> Vec<String> { pub async fn disk_based_diagnostic_sources(&self) -> &[String] {
match self.adapter.as_ref() { match self.adapter.as_ref() {
Some(adapter) => adapter.disk_based_diagnostic_sources().await, Some(adapter) => &adapter.disk_based_diagnostic_sources,
None => Vec::new(), None => &[],
} }
} }
pub async fn disk_based_diagnostics_progress_token(&self) -> Option<String> { pub async fn disk_based_diagnostics_progress_token(&self) -> Option<&str> {
if let Some(adapter) = self.adapter.as_ref() { if let Some(adapter) = self.adapter.as_ref() {
adapter.disk_based_diagnostics_progress_token().await adapter.disk_based_diagnostics_progress_token.as_deref()
} else { } else {
None None
} }
@ -695,7 +763,7 @@ impl CodeLabel {
} }
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
impl Default for FakeLspAdapter { impl Default for FakeLspAdapterInner {
fn default() -> Self { fn default() -> Self {
Self { Self {
name: "the-fake-language-server", name: "the-fake-language-server",
@ -709,7 +777,7 @@ impl Default for FakeLspAdapter {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
#[async_trait] #[async_trait]
impl LspAdapter for FakeLspAdapter { impl LspAdapterTrait for FakeLspAdapter {
async fn name(&self) -> LanguageServerName { async fn name(&self) -> LanguageServerName {
LanguageServerName(self.name.into()) LanguageServerName(self.name.into())
} }

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

@ -740,7 +740,7 @@ impl Project {
for language in self.languages.to_vec() { for language in self.languages.to_vec() {
if let Some(lsp_adapter) = language.lsp_adapter() { if let Some(lsp_adapter) = language.lsp_adapter() {
if !settings.enable_language_server(Some(&language.name())) { if !settings.enable_language_server(Some(&language.name())) {
let lsp_name = lsp_adapter.name().await; let lsp_name = lsp_adapter.name;
for (worktree_id, started_lsp_name) in self.started_language_servers.keys() for (worktree_id, started_lsp_name) in self.started_language_servers.keys()
{ {
if lsp_name == *started_lsp_name { if lsp_name == *started_lsp_name {
@ -1663,7 +1663,7 @@ impl Project {
this.create_local_worktree(&abs_path, false, cx) this.create_local_worktree(&abs_path, false, cx)
}) })
.await?; .await?;
let name = lsp_adapter.name().await; let name = lsp_adapter.name;
this.update(&mut cx, |this, cx| { this.update(&mut cx, |this, cx| {
this.language_servers this.language_servers
.insert((worktree.read(cx).id(), name), (lsp_adapter, lsp_server)); .insert((worktree.read(cx).id(), name), (lsp_adapter, lsp_server));
@ -1816,7 +1816,7 @@ impl Project {
Ok(()) Ok(())
} }
async fn register_buffer_with_language_server( fn register_buffer_with_language_server(
&mut self, &mut self,
buffer_handle: &ModelHandle<Buffer>, buffer_handle: &ModelHandle<Buffer>,
cx: &mut ModelContext<'_, Self>, cx: &mut ModelContext<'_, Self>,
@ -1833,10 +1833,10 @@ impl Project {
if let Some(language) = buffer.language() { if let Some(language) = buffer.language() {
let worktree_id = file.worktree_id(cx); let worktree_id = file.worktree_id(cx);
if let Some(adapter) = language.lsp_adapter() { if let Some(adapter) = language.lsp_adapter() {
language_id = adapter.id_for_language(language.name().as_ref()).await; language_id = adapter.id_for_language.clone();
language_server = self language_server = self
.language_server_ids .language_server_ids
.get(&(worktree_id, adapter.name())) .get(&(worktree_id, adapter.name.clone()))
.and_then(|id| self.language_servers.get(&id)) .and_then(|id| self.language_servers.get(&id))
.and_then(|server_state| { .and_then(|server_state| {
if let LanguageServerState::Running { server, .. } = server_state { if let LanguageServerState::Running { server, .. } = server_state {
@ -2000,11 +2000,7 @@ impl Project {
// that don't support a disk-based progress token. // that don't support a disk-based progress token.
let (lsp_adapter, language_server) = let (lsp_adapter, language_server) =
self.language_server_for_buffer(buffer.read(cx), cx)?; self.language_server_for_buffer(buffer.read(cx), cx)?;
if lsp_adapter if lsp_adapter.disk_based_diagnostics_progress_token.is_none() {
.disk_based_diagnostics_progress_token()
.await
.is_none()
{
let server_id = language_server.server_id(); let server_id = language_server.server_id();
self.disk_based_diagnostics_finished(server_id, cx); self.disk_based_diagnostics_finished(server_id, cx);
self.broadcast_language_server_update( self.broadcast_language_server_update(
@ -2024,10 +2020,9 @@ impl Project {
fn language_servers_for_worktree( fn language_servers_for_worktree(
&self, &self,
worktree_id: WorktreeId, worktree_id: WorktreeId,
) -> impl Iterator<Item = (&Arc<dyn LspAdapter>, &Arc<LanguageServer>)> { ) -> impl Iterator<Item = &(Arc<LspAdapter>, Arc<LanguageServer>)> {
self.language_server_ids self.language_servers.iter().filter_map(
.iter() move |((language_server_worktree_id, _), server)| {
.filter_map(move |((language_server_worktree_id, _), id)| {
if *language_server_worktree_id == worktree_id { if *language_server_worktree_id == worktree_id {
if let Some(LanguageServerState::Running { adapter, server }) = if let Some(LanguageServerState::Running { adapter, server }) =
self.language_servers.get(&id) self.language_servers.get(&id)
@ -2080,8 +2075,8 @@ impl Project {
} else { } else {
return; return;
}; };
let key = (worktree_id, adapter.name());
let key = (worktree_id, adapter.name);
self.language_server_ids self.language_server_ids
.entry(key.clone()) .entry(key.clone())
.or_insert_with(|| { .or_insert_with(|| {
@ -2115,7 +2110,7 @@ impl Project {
this.update(&mut cx, |this, cx| { this.update(&mut cx, |this, cx| {
this.on_lsp_diagnostics_published( this.on_lsp_diagnostics_published(
server_id, params, &adapter, cx, server_id, params, &adapter, cx,
); )
}); });
} }
} }
@ -2427,8 +2422,8 @@ impl Project {
} else { } else {
return; return;
}; };
let server_name = adapter.name();
let stop = self.stop_language_server(worktree_id, server_name.clone(), cx); let stop = self.stop_language_server(worktree_id, adapter.name, cx);
cx.spawn_weak(|this, mut cx| async move { cx.spawn_weak(|this, mut cx| async move {
let (original_root_path, orphaned_worktrees) = stop.await; let (original_root_path, orphaned_worktrees) = stop.await;
if let Some(this) = this.upgrade(&cx) { if let Some(this) = this.upgrade(&cx) {
@ -2464,14 +2459,14 @@ impl Project {
&mut self, &mut self,
server_id: usize, server_id: usize,
mut params: lsp::PublishDiagnosticsParams, mut params: lsp::PublishDiagnosticsParams,
adapter: &Arc<dyn LspAdapter>, adapter: &Arc<LspAdapter>,
cx: &mut ModelContext<'_, Self>, cx: &mut ModelContext<'_, Self>,
) { ) {
adapter.process_diagnostics(&mut params).await; adapter.process_diagnostics(&mut params).await;
self.update_diagnostics( self.update_diagnostics(
server_id, server_id,
params, params,
adapter.disk_based_diagnostic_sources().await, &adapter.disk_based_diagnostic_sources,
cx, cx,
) )
.log_err(); .log_err();
@ -2645,7 +2640,7 @@ impl Project {
this: WeakModelHandle<Self>, this: WeakModelHandle<Self>,
params: lsp::ApplyWorkspaceEditParams, params: lsp::ApplyWorkspaceEditParams,
server_id: usize, server_id: usize,
adapter: Arc<dyn LspAdapter>, adapter: Arc<LspAdapter>,
language_server: Arc<LanguageServer>, language_server: Arc<LanguageServer>,
mut cx: AsyncAppContext, mut cx: AsyncAppContext,
) -> Result<lsp::ApplyWorkspaceEditResponse> { ) -> Result<lsp::ApplyWorkspaceEditResponse> {
@ -2716,7 +2711,7 @@ impl Project {
&mut self, &mut self,
language_server_id: usize, language_server_id: usize,
params: lsp::PublishDiagnosticsParams, params: lsp::PublishDiagnosticsParams,
disk_based_sources: Vec<String>, disk_based_sources: &[String],
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) -> Result<()> { ) -> Result<()> {
let abs_path = params let abs_path = params
@ -3314,7 +3309,7 @@ impl Project {
struct PartialSymbol { struct PartialSymbol {
source_worktree_id: WorktreeId, source_worktree_id: WorktreeId,
worktree_id: WorktreeId, worktree_id: WorktreeId,
adapter: Arc<dyn LspAdapter>, adapter: Arc<LspAdapter>,
path: PathBuf, path: PathBuf,
language: Option<Arc<Language>>, language: Option<Arc<Language>>,
name: String, name: String,
@ -3372,7 +3367,7 @@ impl Project {
} }
.unwrap_or_else(|| CodeLabel::plain(ps.name.clone(), None)); .unwrap_or_else(|| CodeLabel::plain(ps.name.clone(), None));
let language_server_name = ps.adapter.name().await; let language_server_name = ps.adapter.name;
Symbol { Symbol {
source_worktree_id: ps.source_worktree_id, source_worktree_id: ps.source_worktree_id,
@ -4019,7 +4014,7 @@ impl Project {
this: ModelHandle<Self>, this: ModelHandle<Self>,
edit: lsp::WorkspaceEdit, edit: lsp::WorkspaceEdit,
push_to_history: bool, push_to_history: bool,
lsp_adapter: Arc<dyn LspAdapter>, lsp_adapter: Arc<LspAdapter>,
language_server: Arc<LanguageServer>, language_server: Arc<LanguageServer>,
cx: &mut AsyncAppContext, cx: &mut AsyncAppContext,
) -> Result<ProjectTransaction> { ) -> Result<ProjectTransaction> {
@ -6029,10 +6024,9 @@ impl Project {
&self, &self,
buffer: &Buffer, buffer: &Buffer,
cx: &AppContext, cx: &AppContext,
) -> Option<(&Arc<dyn LspAdapter>, &Arc<LanguageServer>)> { ) -> Option<&(Arc<LspAdapter>, Arc<LanguageServer>)> {
if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) { if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) {
// TODO(isaac): this is not a good idea let name = language.lsp_adapter()?.name;
let name = cx.background().block(language.lsp_adapter()?.name());
let worktree_id = file.worktree_id(cx); let worktree_id = file.worktree_id(cx);
let key = (worktree_id, language.lsp_adapter()?.name()); let key = (worktree_id, language.lsp_adapter()?.name());