diff --git a/crates/edit_prediction_cli/src/load_project.rs b/crates/edit_prediction_cli/src/load_project.rs index 5d9c68ccad3013263642939276109b7ab7ef95a4..4d703ffc57c282681c5fbcf35368e5a01839cd24 100644 --- a/crates/edit_prediction_cli/src/load_project.rs +++ b/crates/edit_prediction_cli/src/load_project.rs @@ -223,11 +223,6 @@ pub async fn setup_worktree(example: &Example) { let revision = run_git(&repo_dir, &["rev-parse", "FETCH_HEAD"]) .await .unwrap(); - if revision != example.revision { - run_git(&repo_dir, &["tag", &example.revision, &revision]) - .await - .unwrap(); - } revision }; diff --git a/crates/edit_prediction_cli/src/retrieve_context.rs b/crates/edit_prediction_cli/src/retrieve_context.rs index 955d310b98d6536bd82076a591a599b318a87e64..042c17b8b147c611e826afa26f6c167656babc3b 100644 --- a/crates/edit_prediction_cli/src/retrieve_context.rs +++ b/crates/edit_prediction_cli/src/retrieve_context.rs @@ -3,11 +3,10 @@ use crate::{ headless::EpAppState, load_project::run_load_project, }; -use anyhow::Result; use collections::HashSet; use edit_prediction::{DebugEvent, EditPredictionStore}; use futures::{FutureExt as _, StreamExt as _, channel::mpsc}; -use gpui::{AsyncApp, Entity, Task}; +use gpui::{AsyncApp, Entity}; use language::Buffer; use project::Project; use std::{sync::Arc, time::Duration}; @@ -31,8 +30,7 @@ pub async fn run_context_retrieval( project.register_buffer_with_language_servers(&state.buffer, cx) }) .unwrap(); - - wait_for_language_server_to_start(example, &project, &state.buffer, &mut cx).await; + wait_for_language_servers_to_start(example, &project, &state.buffer, &mut cx).await; let ep_store = cx .update(|cx| EditPredictionStore::try_global(cx).unwrap()) @@ -65,92 +63,73 @@ pub async fn run_context_retrieval( }); } -async fn wait_for_language_server_to_start( +async fn wait_for_language_servers_to_start( example: &Example, project: &Entity, buffer: &Entity, cx: &mut AsyncApp, ) { - let Some(language_id) = buffer - .read_with(cx, |buffer, _cx| { - buffer.language().map(|language| language.id()) - }) - .unwrap() - else { - panic!("No language for {:?}", example.cursor_path); - }; - - let mut ready_languages = HashSet::default(); let log_prefix = format!("{} | ", example.name); - if !ready_languages.contains(&language_id) { - wait_for_lang_server(&project, &buffer, log_prefix, cx) - .await - .unwrap(); - ready_languages.insert(language_id); - } - - let lsp_store = project - .read_with(cx, |project, _cx| project.lsp_store()) - .unwrap(); - - // hacky wait for buffer to be registered with the language server - for _ in 0..100 { - if lsp_store - .update(cx, |lsp_store, cx| { - buffer.update(cx, |buffer, cx| { - lsp_store - .language_servers_for_local_buffer(&buffer, cx) - .next() - .map(|(_, language_server)| language_server.server_id()) - }) - }) - .unwrap() - .is_some() - { - return; - } else { - cx.background_executor() - .timer(Duration::from_millis(10)) - .await; - } - } - - panic!("No language server found for buffer"); -} - -pub fn wait_for_lang_server( - project: &Entity, - buffer: &Entity, - log_prefix: String, - cx: &mut AsyncApp, -) -> Task> { - eprintln!("{}⏵ Waiting for language server", log_prefix); - - let (mut tx, mut rx) = mpsc::channel(1); let lsp_store = project .read_with(cx, |project, _| project.lsp_store()) .unwrap(); - let has_lang_server = buffer + let lang_server_ids = buffer .update(cx, |buffer, cx| { lsp_store.update(cx, |lsp_store, cx| { - lsp_store - .language_servers_for_local_buffer(buffer, cx) - .next() - .is_some() + lsp_store.language_servers_for_local_buffer(buffer, cx) }) }) - .unwrap_or(false); + .unwrap_or_default(); - if has_lang_server { + if !lang_server_ids.is_empty() { project .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx)) .unwrap() .detach(); } - let (mut added_tx, mut added_rx) = mpsc::channel(1); + eprintln!( + "{}⏵ Waiting for {} language servers", + log_prefix, + lang_server_ids.len() + ); + + let timeout = cx + .background_executor() + .timer(Duration::from_secs(60 * 5)) + .shared(); + + let (mut tx, mut rx) = mpsc::channel(lang_server_ids.len()); + let added_subscription = cx.subscribe(project, { + let log_prefix = log_prefix.clone(); + move |_, event, _| match event { + project::Event::LanguageServerAdded(language_server_id, name, _) => { + eprintln!("{}+ Language server started: {}", log_prefix, name); + tx.try_send(*language_server_id).ok(); + } + _ => {} + } + }); + + let mut pending_language_server_ids = HashSet::from_iter(lang_server_ids.iter()); + while !pending_language_server_ids.is_empty() { + futures::select! { + language_server_id = rx.next() => { + if let Some(id) = language_server_id { + pending_language_server_ids.remove(&id); + } + }, + _ = timeout.clone().fuse() => { + panic!("LSP wait timed out after 5 minutes"); + } + } + } + + drop(added_subscription); + + let (mut tx, mut rx) = mpsc::channel(lang_server_ids.len()); let subscriptions = [ cx.subscribe(&lsp_store, { let log_prefix = log_prefix.clone(); @@ -171,45 +150,41 @@ pub fn wait_for_lang_server( } }), cx.subscribe(project, { - let buffer = buffer.clone(); - move |project, event, cx| match event { - project::Event::LanguageServerAdded(_, _, _) => { - let buffer = buffer.clone(); - project - .update(cx, |project, cx| project.save_buffer(buffer, cx)) - .detach(); - added_tx.try_send(()).ok(); - } - project::Event::DiskBasedDiagnosticsFinished { .. } => { - tx.try_send(()).ok(); + let log_prefix = log_prefix.clone(); + move |_, event, cx| match event { + project::Event::DiskBasedDiagnosticsFinished { language_server_id } => { + let lsp_store = lsp_store.read(cx); + let name = lsp_store + .language_server_adapter_for_id(*language_server_id) + .unwrap() + .name(); + eprintln!("{}⚑ Language server idle: {}", log_prefix, name); + tx.try_send(*language_server_id).ok(); } _ => {} } }), ]; - cx.spawn(async move |cx| { - if !has_lang_server { - // some buffers never have a language server, so this aborts quickly in that case. - let timeout = cx.background_executor().timer(Duration::from_secs(500)); - futures::select! { - _ = added_rx.next() => {}, - _ = timeout.fuse() => { - anyhow::bail!("Waiting for language server add timed out after 5 seconds"); + project + .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx)) + .unwrap() + .await + .unwrap(); + + let mut pending_language_server_ids = HashSet::from_iter(lang_server_ids.into_iter()); + while !pending_language_server_ids.is_empty() { + futures::select! { + language_server_id = rx.next() => { + if let Some(id) = language_server_id { + pending_language_server_ids.remove(&id); } - }; - } - let timeout = cx.background_executor().timer(Duration::from_secs(60 * 5)); - let result = futures::select! { - _ = rx.next() => { - eprintln!("{}⚑ Language server idle", log_prefix); - anyhow::Ok(()) }, - _ = timeout.fuse() => { - anyhow::bail!("LSP wait timed out after 5 minutes"); + _ = timeout.clone().fuse() => { + panic!("LSP wait timed out after 5 minutes"); } - }; - drop(subscriptions); - result - }) + } + } + + drop(subscriptions); } diff --git a/crates/eval/src/instance.rs b/crates/eval/src/instance.rs index 787d3372c8248a59e74fc67f347d5bf3b064890f..1af705cd4bfdb4419c767feb41d1428181866c08 100644 --- a/crates/eval/src/instance.rs +++ b/crates/eval/src/instance.rs @@ -892,7 +892,7 @@ pub fn wait_for_lang_server( .update(cx, |buffer, cx| { lsp_store.update(cx, |lsp_store, cx| { lsp_store - .language_servers_for_local_buffer(buffer, cx) + .running_language_servers_for_local_buffer(buffer, cx) .next() .is_some() }) diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 322998594eab2b14a9c8d01d16455ff331f7b99e..25798a6c09c3d8a851e93bd459d92ec8c3c62c77 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -6783,7 +6783,7 @@ impl LspStore { }) } else { let servers = buffer.update(cx, |buffer, cx| { - self.language_servers_for_local_buffer(buffer, cx) + self.running_language_servers_for_local_buffer(buffer, cx) .map(|(_, server)| server.clone()) .collect::>() }); @@ -8123,7 +8123,7 @@ impl LspStore { }) } - pub fn language_servers_for_local_buffer<'a>( + pub fn running_language_servers_for_local_buffer<'a>( &'a self, buffer: &Buffer, cx: &mut App, @@ -8145,6 +8145,17 @@ impl LspStore { ) } + pub fn language_servers_for_local_buffer( + &self, + buffer: &Buffer, + cx: &mut App, + ) -> Vec { + let local = self.as_local(); + local + .map(|local| local.language_server_ids_for_buffer(buffer, cx)) + .unwrap_or_default() + } + pub fn language_server_for_local_buffer<'a>( &'a self, buffer: &'a Buffer, diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 1e5490a2b4bff21450c5cd6a6f0e0fc248df68d4..ec44a60d71e4b0c1f10ad698f727357e60aa3b85 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -5190,7 +5190,7 @@ impl Project { #[cfg(any(test, feature = "test-support"))] pub fn has_language_servers_for(&self, buffer: &Buffer, cx: &mut App) -> bool { self.lsp_store.update(cx, |this, cx| { - this.language_servers_for_local_buffer(buffer, cx) + this.running_language_servers_for_local_buffer(buffer, cx) .next() .is_some() }) diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs index 4a724809c2c4196be49122e7065abe8ec8f139a7..4cebc72073cfda1bf07f028b1aff9fa7410c527d 100644 --- a/crates/project/src/project_tests.rs +++ b/crates/project/src/project_tests.rs @@ -691,7 +691,7 @@ async fn test_running_multiple_instances_of_a_single_server_in_one_worktree( let servers = project.update(cx, |project, cx| { project.lsp_store.update(cx, |this, cx| { first_buffer.update(cx, |buffer, cx| { - this.language_servers_for_local_buffer(buffer, cx) + this.running_language_servers_for_local_buffer(buffer, cx) .map(|(adapter, server)| (adapter.clone(), server.clone())) .collect::>() }) @@ -720,7 +720,7 @@ async fn test_running_multiple_instances_of_a_single_server_in_one_worktree( let servers = project.update(cx, |project, cx| { project.lsp_store.update(cx, |this, cx| { second_project_buffer.update(cx, |buffer, cx| { - this.language_servers_for_local_buffer(buffer, cx) + this.running_language_servers_for_local_buffer(buffer, cx) .map(|(adapter, server)| (adapter.clone(), server.clone())) .collect::>() }) @@ -791,7 +791,7 @@ async fn test_running_multiple_instances_of_a_single_server_in_one_worktree( let servers = project.update(cx, |project, cx| { project.lsp_store.update(cx, |this, cx| { second_project_buffer.update(cx, |buffer, cx| { - this.language_servers_for_local_buffer(buffer, cx) + this.running_language_servers_for_local_buffer(buffer, cx) .map(|(adapter, server)| (adapter.clone(), server.clone())) .collect::>() })