zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-11-07 20:39:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into window_context_2

Browse Source
This commit is contained in:
Antonio Scandurra 2023-04-21 10:58:08 +02:00
commit c76b9794e4
45 changed files with 1760 additions and 882 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.lock generated
View File

@ -1192,7 +1192,7 @@ dependencies = [
[[package]] [[package]]
name = "collab" name = "collab"
version = "0.8.3" version = "0.9.0"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"async-tungstenite", "async-tungstenite",
@ -1834,6 +1834,7 @@ dependencies = [
"editor", "editor",
"gpui", "gpui",
"language", "language",
"lsp",
"postage", "postage",
"project", "project",
"serde_json", "serde_json",
@ -8522,7 +8523,7 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
[[package]] [[package]]
name = "zed" name = "zed"
version = "0.83.0" version = "0.84.0"
dependencies = [ dependencies = [
"activity_indicator", "activity_indicator",
"anyhow", "anyhow",

1
Cargo.toml
View File

@ -76,6 +76,7 @@ serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] } serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
rand = { version = "0.8" } rand = { version = "0.8" }
postage = { version = "0.5", features = ["futures-traits"] } postage = { version = "0.5", features = ["futures-traits"] }
smallvec = { version = "1.6", features = ["union"] }
[patch.crates-io] [patch.crates-io]
tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" } tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" }

15
assets/settings/default.json
View File

@ -197,7 +197,20 @@
// enviroment. Use `:` to seperate multiple values. // enviroment. Use `:` to seperate multiple values.
"env": { "env": {
// "KEY": "value1:value2" // "KEY": "value1:value2"
} },
// Set the terminal's line height.
// May take 3 values:
// 1. Use a line height that's comfortable for reading, 1.618
// "line_height": "comfortable"
// 2. Use a standard line height, 1.3. This option is useful for TUIs,
// particularly if they use box characters
// "line_height": "standard",
// 3. Use a custom line height.
// "line_height": {
// "custom": 2
// },
//
"line_height": "comfortable"
// Set the terminal's font size. If this option is not included, // Set the terminal's font size. If this option is not included,
// the terminal will default to matching the buffer's font size. // the terminal will default to matching the buffer's font size.
// "font_size": "15" // "font_size": "15"

2
crates/activity_indicator/Cargo.toml
View File

@ -18,4 +18,4 @@ settings = { path = "../settings" }
util = { path = "../util" } util = { path = "../util" }
workspace = { path = "../workspace" } workspace = { path = "../workspace" }
futures = "0.3" futures = "0.3"
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }

2
crates/clock/Cargo.toml
View File

@ -9,4 +9,4 @@ path = "src/clock.rs"
doctest = false doctest = false
[dependencies] [dependencies]
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }

2
crates/collab/Cargo.toml
View File

@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
default-run = "collab" default-run = "collab"
edition = "2021" edition = "2021"
name = "collab" name = "collab"
version = "0.8.3" version = "0.9.0"
publish = false publish = false
[[bin]] [[bin]]

7
crates/collab/src/tests/integration_tests.rs
View File

@ -22,6 +22,7 @@ use language::{
LanguageConfig, OffsetRangeExt, Point, Rope, LanguageConfig, OffsetRangeExt, Point, Rope,
}; };
use live_kit_client::MacOSDisplay; use live_kit_client::MacOSDisplay;
use lsp::LanguageServerId;
use project::{search::SearchQuery, DiagnosticSummary, Project, ProjectPath}; use project::{search::SearchQuery, DiagnosticSummary, Project, ProjectPath};
use rand::prelude::*; use rand::prelude::*;
use serde_json::json; use serde_json::json;
@ -3475,6 +3476,7 @@ async fn test_collaborating_with_diagnostics(
worktree_id, worktree_id,
path: Arc::from(Path::new("a.rs")), path: Arc::from(Path::new("a.rs")),
}, },
LanguageServerId(0),
DiagnosticSummary { DiagnosticSummary {
error_count: 1, error_count: 1,
warning_count: 0, warning_count: 0,
@ -3510,6 +3512,7 @@ async fn test_collaborating_with_diagnostics(
worktree_id, worktree_id,
path: Arc::from(Path::new("a.rs")), path: Arc::from(Path::new("a.rs")),
}, },
LanguageServerId(0),
DiagnosticSummary { DiagnosticSummary {
error_count: 1, error_count: 1,
warning_count: 0, warning_count: 0,
@ -3550,10 +3553,10 @@ async fn test_collaborating_with_diagnostics(
worktree_id, worktree_id,
path: Arc::from(Path::new("a.rs")), path: Arc::from(Path::new("a.rs")),
}, },
LanguageServerId(0),
DiagnosticSummary { DiagnosticSummary {
error_count: 1, error_count: 1,
warning_count: 1, warning_count: 1,
..Default::default()
}, },
)] )]
); );
@ -3566,10 +3569,10 @@ async fn test_collaborating_with_diagnostics(
worktree_id, worktree_id,
path: Arc::from(Path::new("a.rs")), path: Arc::from(Path::new("a.rs")),
}, },
LanguageServerId(0),
DiagnosticSummary { DiagnosticSummary {
error_count: 1, error_count: 1,
warning_count: 1, warning_count: 1,
..Default::default()
}, },
)] )]
); );

2
crates/context_menu/Cargo.toml
View File

@ -13,4 +13,4 @@ gpui = { path = "../gpui" }
menu = { path = "../menu" } menu = { path = "../menu" }
settings = { path = "../settings" } settings = { path = "../settings" }
theme = { path = "../theme" } theme = { path = "../theme" }
smallvec = "1.6" smallvec = { workspace = true }

16
crates/copilot/src/copilot.rs
View File

@ -14,7 +14,7 @@ use language::{
ToPointUtf16, ToPointUtf16,
}; };
use log::{debug, error}; use log::{debug, error};
use lsp::LanguageServer; use lsp::{LanguageServer, LanguageServerId};
use node_runtime::NodeRuntime; use node_runtime::NodeRuntime;
use request::{LogMessage, StatusNotification}; use request::{LogMessage, StatusNotification};
use settings::Settings; use settings::Settings;
@ -27,8 +27,7 @@ use std::{
sync::Arc, sync::Arc,
}; };
use util::{ use util::{
channel::ReleaseChannel, fs::remove_matching, github::latest_github_release, http::HttpClient, fs::remove_matching, github::latest_github_release, http::HttpClient, paths, ResultExt,
paths, ResultExt,
}; };
const COPILOT_AUTH_NAMESPACE: &'static str = "copilot_auth"; const COPILOT_AUTH_NAMESPACE: &'static str = "copilot_auth";
@ -41,15 +40,6 @@ actions!(
); );
pub fn init(http: Arc<dyn HttpClient>, node_runtime: Arc<NodeRuntime>, cx: &mut AppContext) { pub fn init(http: Arc<dyn HttpClient>, node_runtime: Arc<NodeRuntime>, cx: &mut AppContext) {
// Disable Copilot for stable releases.
if *cx.global::<ReleaseChannel>() == ReleaseChannel::Stable {
cx.update_global::<collections::CommandPaletteFilter, _, _>(|filter, _cx| {
filter.filtered_namespaces.insert(COPILOT_NAMESPACE);
filter.filtered_namespaces.insert(COPILOT_AUTH_NAMESPACE);
});
return;
}
let copilot = cx.add_model({ let copilot = cx.add_model({
let node_runtime = node_runtime.clone(); let node_runtime = node_runtime.clone();
move |cx| Copilot::start(http, node_runtime, cx) move |cx| Copilot::start(http, node_runtime, cx)
@ -380,7 +370,7 @@ impl Copilot {
let node_path = node_runtime.binary_path().await?; let node_path = node_runtime.binary_path().await?;
let arguments: &[OsString] = &[server_path.into(), "--stdio".into()]; let arguments: &[OsString] = &[server_path.into(), "--stdio".into()];
let server = LanguageServer::new( let server = LanguageServer::new(
0, LanguageServerId(0),
&node_path, &node_path,
arguments, arguments,
Path::new("/"), Path::new("/"),

80
crates/copilot/src/sign_in.rs
View File

@ -24,55 +24,57 @@ struct OpenGithub;
const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot"; const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot";
pub fn init(cx: &mut AppContext) { pub fn init(cx: &mut AppContext) {
let copilot = Copilot::global(cx).unwrap(); if let Some(copilot) = Copilot::global(cx) {
let mut code_verification: Option<ViewHandle<CopilotCodeVerification>> = None;
cx.observe(&copilot, move |copilot, cx| {
let status = copilot.read(cx).status();
let mut code_verification: Option<ViewHandle<CopilotCodeVerification>> = None; match &status {
cx.observe(&copilot, move |copilot, cx| { crate::Status::SigningIn { prompt } => {
let status = copilot.read(cx).status(); if let Some(code_verification_handle) = code_verification.as_mut() {
let window_id = code_verification_handle.window_id();
match &status { if cx.has_window(window_id) {
crate::Status::SigningIn { prompt } => { cx.update_window(window_id, |cx| {
if let Some(code_verification) = code_verification.as_mut() { code_verification_handle.update(cx, |code_verification, cx| {
if cx.has_window(code_verification.window_id()) { code_verification.set_status(status, cx)
cx.update_window(code_verification.window_id(), |cx| { });
code_verification.update(cx, |code_verification_view, cx| {
code_verification_view.set_status(status, cx);
cx.activate_window(); cx.activate_window();
}); });
}); } else {
} else { code_verification = Some(create_copilot_auth_window(cx, &status));
*code_verification = create_copilot_auth_window(cx, &status); }
} else if let Some(_prompt) = prompt {
code_verification = Some(create_copilot_auth_window(cx, &status));
} }
} else if let Some(_prompt) = prompt {
code_verification = Some(create_copilot_auth_window(cx, &status));
} }
} Status::Authorized | Status::Unauthorized => {
Status::Authorized | Status::Unauthorized => { if let Some(code_verification) = code_verification.as_ref() {
if let Some(code_verification) = code_verification.as_ref() { let window_id = code_verification.window_id();
cx.update_window(code_verification.window_id(), |cx| { cx.update_window(window_id, |cx| {
code_verification.update(cx, |code_verification, cx| { code_verification.update(cx, |code_verification, cx| {
code_verification.set_status(status, cx); code_verification.set_status(status, cx)
});
cx.platform().activate(true);
cx.activate_window(); cx.activate_window();
}); });
}
cx.platform().activate(true); }
}); _ => {
if let Some(code_verification) = code_verification.take() {
cx.remove_window(code_verification.window_id());
}
} }
} }
_ => { })
if let Some(code_verification) = code_verification.take() { .detach();
cx.remove_window(code_verification.window_id());
}
}
}
})
.detach();
cx.add_action( cx.add_action(
|code_verification: &mut CopilotCodeVerification, _: &ClickedConnect, _| { |code_verification: &mut CopilotCodeVerification, _: &ClickedConnect, _| {
code_verification.connect_clicked = true; code_verification.connect_clicked = true;
}, },
); );
}
} }
fn create_copilot_auth_window( fn create_copilot_auth_window(

4
crates/diagnostics/Cargo.toml
View File

@ -10,10 +10,11 @@ doctest = false
[dependencies] [dependencies]
anyhow = "1.0" anyhow = "1.0"
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
collections = { path = "../collections" } collections = { path = "../collections" }
editor = { path = "../editor" } editor = { path = "../editor" }
language = { path = "../language" } language = { path = "../language" }
lsp = { path = "../lsp" }
gpui = { path = "../gpui" } gpui = { path = "../gpui" }
project = { path = "../project" } project = { path = "../project" }
settings = { path = "../settings" } settings = { path = "../settings" }
@ -27,6 +28,7 @@ unindent = "0.1"
client = { path = "../client", features = ["test-support"] } client = { path = "../client", features = ["test-support"] }
editor = { path = "../editor", features = ["test-support"] } editor = { path = "../editor", features = ["test-support"] }
language = { path = "../language", features = ["test-support"] } language = { path = "../language", features = ["test-support"] }
lsp = { path = "../lsp", features = ["test-support"] }
gpui = { path = "../gpui", features = ["test-support"] } gpui = { path = "../gpui", features = ["test-support"] }
workspace = { path = "../workspace", features = ["test-support"] } workspace = { path = "../workspace", features = ["test-support"] }
serde_json = { workspace = true } serde_json = { workspace = true }

364
crates/diagnostics/src/diagnostics.rs
View File

@ -1,7 +1,7 @@
pub mod items; pub mod items;
use anyhow::Result; use anyhow::Result;
use collections::{BTreeMap, HashSet}; use collections::{BTreeSet, HashSet};
use editor::{ use editor::{
diagnostic_block_renderer, diagnostic_block_renderer,
display_map::{BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock}, display_map::{BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock},
@ -17,6 +17,7 @@ use language::{
Anchor, Bias, Buffer, Diagnostic, DiagnosticEntry, DiagnosticSeverity, Point, Selection, Anchor, Bias, Buffer, Diagnostic, DiagnosticEntry, DiagnosticSeverity, Point, Selection,
SelectionGoal, SelectionGoal,
}; };
use lsp::LanguageServerId;
use project::{DiagnosticSummary, Project, ProjectPath}; use project::{DiagnosticSummary, Project, ProjectPath};
use serde_json::json; use serde_json::json;
use settings::Settings; use settings::Settings;
@ -55,7 +56,7 @@ struct ProjectDiagnosticsEditor {
summary: DiagnosticSummary, summary: DiagnosticSummary,
excerpts: ModelHandle<MultiBuffer>, excerpts: ModelHandle<MultiBuffer>,
path_states: Vec<PathState>, path_states: Vec<PathState>,
paths_to_update: BTreeMap<ProjectPath, usize>, paths_to_update: BTreeSet<(ProjectPath, LanguageServerId)>,
} }
struct PathState { struct PathState {
@ -71,6 +72,7 @@ struct Jump {
} }
struct DiagnosticGroupState { struct DiagnosticGroupState {
language_server_id: LanguageServerId,
primary_diagnostic: DiagnosticEntry<language::Anchor>, primary_diagnostic: DiagnosticEntry<language::Anchor>,
primary_excerpt_ix: usize, primary_excerpt_ix: usize,
excerpts: Vec<ExcerptId>, excerpts: Vec<ExcerptId>,
@ -115,7 +117,7 @@ impl View for ProjectDiagnosticsEditor {
}), }),
"summary": self.summary, "summary": self.summary,
"paths_to_update": self.paths_to_update.iter().map(|(path, server_id)| "paths_to_update": self.paths_to_update.iter().map(|(path, server_id)|
(path.path.to_string_lossy(), server_id) (path.path.to_string_lossy(), server_id.0)
).collect::<Vec<_>>(), ).collect::<Vec<_>>(),
"paths_states": self.path_states.iter().map(|state| "paths_states": self.path_states.iter().map(|state|
json!({ json!({
@ -148,7 +150,7 @@ impl ProjectDiagnosticsEditor {
path, path,
} => { } => {
this.paths_to_update this.paths_to_update
.insert(path.clone(), *language_server_id); .insert((path.clone(), *language_server_id));
} }
_ => {} _ => {}
}) })
@ -167,7 +169,7 @@ impl ProjectDiagnosticsEditor {
let project = project_handle.read(cx); let project = project_handle.read(cx);
let paths_to_update = project let paths_to_update = project
.diagnostic_summaries(cx) .diagnostic_summaries(cx)
.map(|e| (e.0, e.1.language_server_id)) .map(|(path, server_id, _)| (path, server_id))
.collect(); .collect();
let summary = project.diagnostic_summary(cx); let summary = project.diagnostic_summary(cx);
let mut this = Self { let mut this = Self {
@ -195,9 +197,13 @@ impl ProjectDiagnosticsEditor {
} }
} }
fn update_excerpts(&mut self, language_server_id: Option<usize>, cx: &mut ViewContext<Self>) { fn update_excerpts(
&mut self,
language_server_id: Option<LanguageServerId>,
cx: &mut ViewContext<Self>,
) {
let mut paths = Vec::new(); let mut paths = Vec::new();
self.paths_to_update.retain(|path, server_id| { self.paths_to_update.retain(|(path, server_id)| {
if language_server_id if language_server_id
.map_or(true, |language_server_id| language_server_id == *server_id) .map_or(true, |language_server_id| language_server_id == *server_id)
{ {
@ -214,7 +220,9 @@ impl ProjectDiagnosticsEditor {
let buffer = project let buffer = project
.update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx)) .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))
.await?; .await?;
this.update(&mut cx, |this, cx| this.populate_excerpts(path, buffer, cx))?; this.update(&mut cx, |this, cx| {
this.populate_excerpts(path, language_server_id, buffer, cx)
})?;
} }
Result::<_, anyhow::Error>::Ok(()) Result::<_, anyhow::Error>::Ok(())
} }
@ -226,6 +234,7 @@ impl ProjectDiagnosticsEditor {
fn populate_excerpts( fn populate_excerpts(
&mut self, &mut self,
path: ProjectPath, path: ProjectPath,
language_server_id: Option<LanguageServerId>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) { ) {
@ -264,9 +273,9 @@ impl ProjectDiagnosticsEditor {
let excerpts_snapshot = self.excerpts.update(cx, |excerpts, excerpts_cx| { let excerpts_snapshot = self.excerpts.update(cx, |excerpts, excerpts_cx| {
let mut old_groups = path_state.diagnostic_groups.iter().enumerate().peekable(); let mut old_groups = path_state.diagnostic_groups.iter().enumerate().peekable();
let mut new_groups = snapshot let mut new_groups = snapshot
.diagnostic_groups() .diagnostic_groups(language_server_id)
.into_iter() .into_iter()
.filter(|group| { .filter(|(_, group)| {
group.entries[group.primary_ix].diagnostic.severity group.entries[group.primary_ix].diagnostic.severity
<= DiagnosticSeverity::WARNING <= DiagnosticSeverity::WARNING
}) })
@ -278,12 +287,27 @@ impl ProjectDiagnosticsEditor {
match (old_groups.peek(), new_groups.peek()) { match (old_groups.peek(), new_groups.peek()) {
(None, None) => break, (None, None) => break,
(None, Some(_)) => to_insert = new_groups.next(), (None, Some(_)) => to_insert = new_groups.next(),
(Some(_), None) => to_remove = old_groups.next(), (Some((_, old_group)), None) => {
(Some((_, old_group)), Some(new_group)) => { if language_server_id.map_or(true, |id| id == old_group.language_server_id)
{
to_remove = old_groups.next();
} else {
to_keep = old_groups.next();
}
}
(Some((_, old_group)), Some((_, new_group))) => {
let old_primary = &old_group.primary_diagnostic; let old_primary = &old_group.primary_diagnostic;
let new_primary = &new_group.entries[new_group.primary_ix]; let new_primary = &new_group.entries[new_group.primary_ix];
match compare_diagnostics(old_primary, new_primary, &snapshot) { match compare_diagnostics(old_primary, new_primary, &snapshot) {
Ordering::Less => to_remove = old_groups.next(), Ordering::Less => {
if language_server_id
.map_or(true, |id| id == old_group.language_server_id)
{
to_remove = old_groups.next();
} else {
to_keep = old_groups.next();
}
}
Ordering::Equal => { Ordering::Equal => {
to_keep = old_groups.next(); to_keep = old_groups.next();
new_groups.next(); new_groups.next();
@ -293,8 +317,9 @@ impl ProjectDiagnosticsEditor {
} }
} }
if let Some(group) = to_insert { if let Some((language_server_id, group)) = to_insert {
let mut group_state = DiagnosticGroupState { let mut group_state = DiagnosticGroupState {
language_server_id,
primary_diagnostic: group.entries[group.primary_ix].clone(), primary_diagnostic: group.entries[group.primary_ix].clone(),
primary_excerpt_ix: 0, primary_excerpt_ix: 0,
excerpts: Default::default(), excerpts: Default::default(),
@ -772,26 +797,24 @@ mod tests {
}; };
use gpui::{TestAppContext, WindowContext}; use gpui::{TestAppContext, WindowContext};
use language::{Diagnostic, DiagnosticEntry, DiagnosticSeverity, PointUtf16, Unclipped}; use language::{Diagnostic, DiagnosticEntry, DiagnosticSeverity, PointUtf16, Unclipped};
use project::FakeFs;
use serde_json::json; use serde_json::json;
use unindent::Unindent as _; use unindent::Unindent as _;
use workspace::AppState;
#[gpui::test] #[gpui::test]
async fn test_diagnostics(cx: &mut TestAppContext) { async fn test_diagnostics(cx: &mut TestAppContext) {
let app_state = cx.update(AppState::test); Settings::test_async(cx);
app_state let fs = FakeFs::new(cx.background());
.fs fs.insert_tree(
.as_fake() "/test",
.insert_tree( json!({
"/test", "consts.rs": "
json!({
"consts.rs": "
const a: i32 = 'a'; const a: i32 = 'a';
const b: i32 = c; const b: i32 = c;
" "
.unindent(), .unindent(),
"main.rs": " "main.rs": "
fn main() { fn main() {
let x = vec![]; let x = vec![];
let y = vec![]; let y = vec![];
@ -803,19 +826,20 @@ mod tests {
d(x); d(x);
} }
" "
.unindent(), .unindent(),
}), }),
) )
.await; .await;
let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await; let language_server_id = LanguageServerId(0);
let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx)); let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
// Create some diagnostics // Create some diagnostics
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project project
.update_diagnostic_entries( .update_diagnostic_entries(
0, language_server_id,
PathBuf::from("/test/main.rs"), PathBuf::from("/test/main.rs"),
None, None,
vec![ vec![
@ -964,10 +988,10 @@ mod tests {
// Diagnostics are added for another earlier path. // Diagnostics are added for another earlier path.
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project.disk_based_diagnostics_started(0, cx); project.disk_based_diagnostics_started(language_server_id, cx);
project project
.update_diagnostic_entries( .update_diagnostic_entries(
0, language_server_id,
PathBuf::from("/test/consts.rs"), PathBuf::from("/test/consts.rs"),
None, None,
vec![DiagnosticEntry { vec![DiagnosticEntry {
@ -984,7 +1008,7 @@ mod tests {
cx, cx,
) )
.unwrap(); .unwrap();
project.disk_based_diagnostics_finished(0, cx); project.disk_based_diagnostics_finished(language_server_id, cx);
}); });
view.next_notification(cx).await; view.next_notification(cx).await;
@ -1064,10 +1088,10 @@ mod tests {
// Diagnostics are added to the first path // Diagnostics are added to the first path
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project.disk_based_diagnostics_started(0, cx); project.disk_based_diagnostics_started(language_server_id, cx);
project project
.update_diagnostic_entries( .update_diagnostic_entries(
0, language_server_id,
PathBuf::from("/test/consts.rs"), PathBuf::from("/test/consts.rs"),
None, None,
vec![ vec![
@ -1100,7 +1124,7 @@ mod tests {
cx, cx,
) )
.unwrap(); .unwrap();
project.disk_based_diagnostics_finished(0, cx); project.disk_based_diagnostics_finished(language_server_id, cx);
}); });
view.next_notification(cx).await; view.next_notification(cx).await;
@ -1180,6 +1204,272 @@ mod tests {
}); });
} }
#[gpui::test]
async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
Settings::test_async(cx);
let fs = FakeFs::new(cx.background());
fs.insert_tree(
"/test",
json!({
"main.js": "
a();
b();
c();
d();
e();
".unindent()
}),
)
.await;
let server_id_1 = LanguageServerId(100);
let server_id_2 = LanguageServerId(101);
let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
let view = cx.add_view(&workspace, |cx| {
ProjectDiagnosticsEditor::new(project.clone(), workspace.downgrade(), cx)
});
// Two language servers start updating diagnostics
project.update(cx, |project, cx| {
project.disk_based_diagnostics_started(server_id_1, cx);
project.disk_based_diagnostics_started(server_id_2, cx);
project
.update_diagnostic_entries(
server_id_1,
PathBuf::from("/test/main.js"),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(0, 0))..Unclipped(PointUtf16::new(0, 1)),
diagnostic: Diagnostic {
message: "error 1".to_string(),
severity: DiagnosticSeverity::WARNING,
is_primary: true,
is_disk_based: true,
group_id: 1,
..Default::default()
},
}],
cx,
)
.unwrap();
project
.update_diagnostic_entries(
server_id_2,
PathBuf::from("/test/main.js"),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(1, 0))..Unclipped(PointUtf16::new(1, 1)),
diagnostic: Diagnostic {
message: "warning 1".to_string(),
severity: DiagnosticSeverity::ERROR,
is_primary: true,
is_disk_based: true,
group_id: 2,
..Default::default()
},
}],
cx,
)
.unwrap();
});
// The first language server finishes
project.update(cx, |project, cx| {
project.disk_based_diagnostics_finished(server_id_1, cx);
});
// Only the first language server's diagnostics are shown.
cx.foreground().run_until_parked();
view.update(cx, |view, cx| {
assert_eq!(
editor_blocks(&view.editor, cx),
[
(0, "path header block".into()),
(2, "diagnostic header".into()),
]
);
assert_eq!(
view.editor.update(cx, |editor, cx| editor.display_text(cx)),
concat!(
"\n", // filename
"\n", // padding
// diagnostic group 1
"\n", // primary message
"\n", // padding
"a();\n", //
"b();",
)
);
});
// The second language server finishes
project.update(cx, |project, cx| {
project.disk_based_diagnostics_finished(server_id_2, cx);
});
// Both language server's diagnostics are shown.
cx.foreground().run_until_parked();
view.update(cx, |view, cx| {
assert_eq!(
editor_blocks(&view.editor, cx),
[
(0, "path header block".into()),
(2, "diagnostic header".into()),
(6, "collapsed context".into()),
(7, "diagnostic header".into()),
]
);
assert_eq!(
view.editor.update(cx, |editor, cx| editor.display_text(cx)),
concat!(
"\n", // filename
"\n", // padding
// diagnostic group 1
"\n", // primary message
"\n", // padding
"a();\n", // location
"b();\n", //
"\n", // collapsed context
// diagnostic group 2
"\n", // primary message
"\n", // padding
"a();\n", // context
"b();\n", //
"c();", // context
)
);
});
// Both language servers start updating diagnostics, and the first server finishes.
project.update(cx, |project, cx| {
project.disk_based_diagnostics_started(server_id_1, cx);
project.disk_based_diagnostics_started(server_id_2, cx);
project
.update_diagnostic_entries(
server_id_1,
PathBuf::from("/test/main.js"),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(2, 0))..Unclipped(PointUtf16::new(2, 1)),
diagnostic: Diagnostic {
message: "warning 2".to_string(),
severity: DiagnosticSeverity::WARNING,
is_primary: true,
is_disk_based: true,
group_id: 1,
..Default::default()
},
}],
cx,
)
.unwrap();
project
.update_diagnostic_entries(
server_id_2,
PathBuf::from("/test/main.rs"),
None,
vec![],
cx,
)
.unwrap();
project.disk_based_diagnostics_finished(server_id_1, cx);
});
// Only the first language server's diagnostics are updated.
cx.foreground().run_until_parked();
view.update(cx, |view, cx| {
assert_eq!(
editor_blocks(&view.editor, cx),
[
(0, "path header block".into()),
(2, "diagnostic header".into()),
(7, "collapsed context".into()),
(8, "diagnostic header".into()),
]
);
assert_eq!(
view.editor.update(cx, |editor, cx| editor.display_text(cx)),
concat!(
"\n", // filename
"\n", // padding
// diagnostic group 1
"\n", // primary message
"\n", // padding
"a();\n", // location
"b();\n", //
"c();\n", // context
"\n", // collapsed context
// diagnostic group 2
"\n", // primary message
"\n", // padding
"b();\n", // context
"c();\n", //
"d();", // context
)
);
});
// The second language server finishes.
project.update(cx, |project, cx| {
project
.update_diagnostic_entries(
server_id_2,
PathBuf::from("/test/main.js"),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(3, 0))..Unclipped(PointUtf16::new(3, 1)),
diagnostic: Diagnostic {
message: "warning 2".to_string(),
severity: DiagnosticSeverity::WARNING,
is_primary: true,
is_disk_based: true,
group_id: 1,
..Default::default()
},
}],
cx,
)
.unwrap();
project.disk_based_diagnostics_finished(server_id_2, cx);
});
// Both language servers' diagnostics are updated.
cx.foreground().run_until_parked();
view.update(cx, |view, cx| {
assert_eq!(
editor_blocks(&view.editor, cx),
[
(0, "path header block".into()),
(2, "diagnostic header".into()),
(7, "collapsed context".into()),
(8, "diagnostic header".into()),
]
);
assert_eq!(
view.editor.update(cx, |editor, cx| editor.display_text(cx)),
concat!(
"\n", // filename
"\n", // padding
// diagnostic group 1
"\n", // primary message
"\n", // padding
"b();\n", // location
"c();\n", //
"d();\n", // context
"\n", // collapsed context
// diagnostic group 2
"\n", // primary message
"\n", // padding
"c();\n", // context
"d();\n", //
"e();", // context
)
);
});
}
fn editor_blocks(editor: &ViewHandle<Editor>, cx: &mut WindowContext) -> Vec<(u32, String)> { fn editor_blocks(editor: &ViewHandle<Editor>, cx: &mut WindowContext) -> Vec<(u32, String)> {
editor.update(cx, |editor, cx| { editor.update(cx, |editor, cx| {
let snapshot = editor.snapshot(cx); let snapshot = editor.snapshot(cx);

3
crates/diagnostics/src/items.rs
View File

@ -7,6 +7,7 @@ use gpui::{
WeakViewHandle, WeakViewHandle,
}; };
use language::Diagnostic; use language::Diagnostic;
use lsp::LanguageServerId;
use project::Project; use project::Project;
use settings::Settings; use settings::Settings;
use workspace::{item::ItemHandle, StatusItemView}; use workspace::{item::ItemHandle, StatusItemView};
@ -15,7 +16,7 @@ pub struct DiagnosticIndicator {
summary: project::DiagnosticSummary, summary: project::DiagnosticSummary,
active_editor: Option<WeakViewHandle<Editor>>, active_editor: Option<WeakViewHandle<Editor>>,
current_diagnostic: Option<Diagnostic>, current_diagnostic: Option<Diagnostic>,
in_progress_checks: HashSet<usize>, in_progress_checks: HashSet<LanguageServerId>,
_observe_active_editor: Option<Subscription>, _observe_active_editor: Option<Subscription>,
} }

2
crates/editor/Cargo.toml
View File

@ -58,7 +58,7 @@ postage = { workspace = true }
rand = { version = "0.8.3", optional = true } rand = { version = "0.8.3", optional = true }
serde = { workspace = true } serde = { workspace = true }
serde_derive = { workspace = true } serde_derive = { workspace = true }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2" smol = "1.2"
tree-sitter-rust = { version = "*", optional = true } tree-sitter-rust = { version = "*", optional = true }
tree-sitter-html = { version = "*", optional = true } tree-sitter-html = { version = "*", optional = true }

6
crates/editor/src/editor_tests.rs
View File

@ -4411,7 +4411,7 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut gpui::TestAppContext)
cx.set_state( cx.set_state(
&[ &[
"one ", // "one ", //
"twoˇ", // "twoˇ", //
"three ", // "three ", //
"four", // "four", //
] ]
@ -4486,7 +4486,7 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut gpui::TestAppContext)
&[ &[
"one", // "one", //
"", // "", //
"twoˇ", // "twoˇ", //
"", // "", //
"three", // "three", //
"four", // "four", //
@ -4501,7 +4501,7 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut gpui::TestAppContext)
cx.assert_editor_state( cx.assert_editor_state(
&[ &[
"one ", // "one ", //
"twoˇ", // "twoˇ", //
"three ", // "three ", //
"four", // "four", //
] ]

3
crates/editor/src/hover_popover.rs
View File

@ -436,6 +436,7 @@ mod tests {
use indoc::indoc; use indoc::indoc;
use language::{Diagnostic, DiagnosticSet}; use language::{Diagnostic, DiagnosticSet};
use lsp::LanguageServerId;
use project::HoverBlock; use project::HoverBlock;
use smol::stream::StreamExt; use smol::stream::StreamExt;
@ -620,7 +621,7 @@ mod tests {
}], }],
&snapshot, &snapshot,
); );
buffer.update_diagnostics(set, cx); buffer.update_diagnostics(LanguageServerId(0), set, cx);
}); });
// Hover pops diagnostic immediately // Hover pops diagnostic immediately

11
crates/editor/src/multi_buffer.rs
View File

@ -2764,6 +2764,15 @@ impl MultiBufferSnapshot {
.and_then(|(buffer, offset)| buffer.language_scope_at(offset)) .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
} }
pub fn language_indent_size_at<T: ToOffset>(
&self,
position: T,
cx: &AppContext,
) -> Option<IndentSize> {
let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
Some(buffer_snapshot.language_indent_size_at(offset, cx))
}
pub fn is_dirty(&self) -> bool { pub fn is_dirty(&self) -> bool {
self.is_dirty self.is_dirty
} }
@ -2791,7 +2800,7 @@ impl MultiBufferSnapshot {
) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
where where
T: 'a + ToOffset, T: 'a + ToOffset,
O: 'a + text::FromAnchor, O: 'a + text::FromAnchor + Ord,
{ {
self.as_singleton() self.as_singleton()
.into_iter() .into_iter()

2
crates/gpui/Cargo.toml
View File

@ -44,7 +44,7 @@ seahash = "4.1"
serde = { workspace = true } serde = { workspace = true }
serde_derive = { workspace = true } serde_derive = { workspace = true }
serde_json = { workspace = true } serde_json = { workspace = true }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2" smol = "1.2"
time = { version = "0.3", features = ["serde", "serde-well-known"] } time = { version = "0.3", features = ["serde", "serde-well-known"] }
tiny-skia = "0.5" tiny-skia = "0.5"

2
crates/language/Cargo.toml
View File

@ -50,7 +50,7 @@ serde = { workspace = true }
serde_derive = { workspace = true } serde_derive = { workspace = true }
serde_json = { workspace = true } serde_json = { workspace = true }
similar = "1.3" similar = "1.3"
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2" smol = "1.2"
tree-sitter = "0.20" tree-sitter = "0.20"
tree-sitter-rust = { version = "*", optional = true } tree-sitter-rust = { version = "*", optional = true }

96
crates/language/src/buffer.rs
View File

@ -16,9 +16,11 @@ use clock::ReplicaId;
use fs::LineEnding; use fs::LineEnding;
use futures::FutureExt as _; use futures::FutureExt as _;
use gpui::{fonts::HighlightStyle, AppContext, Entity, ModelContext, Task}; use gpui::{fonts::HighlightStyle, AppContext, Entity, ModelContext, Task};
use lsp::LanguageServerId;
use parking_lot::Mutex; use parking_lot::Mutex;
use settings::Settings; use settings::Settings;
use similar::{ChangeTag, TextDiff}; use similar::{ChangeTag, TextDiff};
use smallvec::SmallVec;
use smol::future::yield_now; use smol::future::yield_now;
use std::{ use std::{
any::Any, any::Any,
@ -71,7 +73,7 @@ pub struct Buffer {
syntax_map: Mutex<SyntaxMap>, syntax_map: Mutex<SyntaxMap>,
parsing_in_background: bool, parsing_in_background: bool,
parse_count: usize, parse_count: usize,
diagnostics: DiagnosticSet, diagnostics: SmallVec<[(LanguageServerId, DiagnosticSet); 2]>,
remote_selections: TreeMap<ReplicaId, SelectionSet>, remote_selections: TreeMap<ReplicaId, SelectionSet>,
selections_update_count: usize, selections_update_count: usize,
diagnostics_update_count: usize, diagnostics_update_count: usize,
@ -88,7 +90,7 @@ pub struct BufferSnapshot {
pub git_diff: git::diff::BufferDiff, pub git_diff: git::diff::BufferDiff,
pub(crate) syntax: SyntaxSnapshot, pub(crate) syntax: SyntaxSnapshot,
file: Option<Arc<dyn File>>, file: Option<Arc<dyn File>>,
diagnostics: DiagnosticSet, diagnostics: SmallVec<[(LanguageServerId, DiagnosticSet); 2]>,
diagnostics_update_count: usize, diagnostics_update_count: usize,
file_update_count: usize, file_update_count: usize,
git_diff_update_count: usize, git_diff_update_count: usize,
@ -156,6 +158,7 @@ pub struct Completion {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct CodeAction { pub struct CodeAction {
pub server_id: LanguageServerId,
pub range: Range<Anchor>, pub range: Range<Anchor>,
pub lsp_action: lsp::CodeAction, pub lsp_action: lsp::CodeAction,
} }
@ -163,16 +166,20 @@ pub struct CodeAction {
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum Operation { pub enum Operation {
Buffer(text::Operation), Buffer(text::Operation),
UpdateDiagnostics { UpdateDiagnostics {
server_id: LanguageServerId,
diagnostics: Arc<[DiagnosticEntry<Anchor>]>, diagnostics: Arc<[DiagnosticEntry<Anchor>]>,
lamport_timestamp: clock::Lamport, lamport_timestamp: clock::Lamport,
}, },
UpdateSelections { UpdateSelections {
selections: Arc<[Selection<Anchor>]>, selections: Arc<[Selection<Anchor>]>,
lamport_timestamp: clock::Lamport, lamport_timestamp: clock::Lamport,
line_mode: bool, line_mode: bool,
cursor_shape: CursorShape, cursor_shape: CursorShape,
}, },
UpdateCompletionTriggers { UpdateCompletionTriggers {
triggers: Vec<String>, triggers: Vec<String>,
lamport_timestamp: clock::Lamport, lamport_timestamp: clock::Lamport,
@ -408,6 +415,7 @@ impl Buffer {
) -> Task<Vec<proto::Operation>> { ) -> Task<Vec<proto::Operation>> {
let mut operations = Vec::new(); let mut operations = Vec::new();
operations.extend(self.deferred_ops.iter().map(proto::serialize_operation)); operations.extend(self.deferred_ops.iter().map(proto::serialize_operation));
operations.extend(self.remote_selections.iter().map(|(_, set)| { operations.extend(self.remote_selections.iter().map(|(_, set)| {
proto::serialize_operation(&Operation::UpdateSelections { proto::serialize_operation(&Operation::UpdateSelections {
selections: set.selections.clone(), selections: set.selections.clone(),
@ -416,10 +424,15 @@ impl Buffer {
cursor_shape: set.cursor_shape, cursor_shape: set.cursor_shape,
}) })
})); }));
operations.push(proto::serialize_operation(&Operation::UpdateDiagnostics {
diagnostics: self.diagnostics.iter().cloned().collect(), for (server_id, diagnostics) in &self.diagnostics {
lamport_timestamp: self.diagnostics_timestamp, operations.push(proto::serialize_operation(&Operation::UpdateDiagnostics {
})); lamport_timestamp: self.diagnostics_timestamp,
server_id: *server_id,
diagnostics: diagnostics.iter().cloned().collect(),
}));
}
operations.push(proto::serialize_operation( operations.push(proto::serialize_operation(
&Operation::UpdateCompletionTriggers { &Operation::UpdateCompletionTriggers {
triggers: self.completion_triggers.clone(), triggers: self.completion_triggers.clone(),
@ -865,13 +878,19 @@ impl Buffer {
cx.notify(); cx.notify();
} }
pub fn update_diagnostics(&mut self, diagnostics: DiagnosticSet, cx: &mut ModelContext<Self>) { pub fn update_diagnostics(
&mut self,
server_id: LanguageServerId,
diagnostics: DiagnosticSet,
cx: &mut ModelContext<Self>,
) {
let lamport_timestamp = self.text.lamport_clock.tick(); let lamport_timestamp = self.text.lamport_clock.tick();
let op = Operation::UpdateDiagnostics { let op = Operation::UpdateDiagnostics {
server_id,
diagnostics: diagnostics.iter().cloned().collect(), diagnostics: diagnostics.iter().cloned().collect(),
lamport_timestamp, lamport_timestamp,
}; };
self.apply_diagnostic_update(diagnostics, lamport_timestamp, cx); self.apply_diagnostic_update(server_id, diagnostics, lamport_timestamp, cx);
self.send_operation(op, cx); self.send_operation(op, cx);
} }
@ -1579,11 +1598,13 @@ impl Buffer {
unreachable!("buffer operations should never be applied at this layer") unreachable!("buffer operations should never be applied at this layer")
} }
Operation::UpdateDiagnostics { Operation::UpdateDiagnostics {
server_id,
diagnostics: diagnostic_set, diagnostics: diagnostic_set,
lamport_timestamp, lamport_timestamp,
} => { } => {
let snapshot = self.snapshot(); let snapshot = self.snapshot();
self.apply_diagnostic_update( self.apply_diagnostic_update(
server_id,
DiagnosticSet::from_sorted_entries(diagnostic_set.iter().cloned(), &snapshot), DiagnosticSet::from_sorted_entries(diagnostic_set.iter().cloned(), &snapshot),
lamport_timestamp, lamport_timestamp,
cx, cx,
@ -1625,12 +1646,16 @@ impl Buffer {
fn apply_diagnostic_update( fn apply_diagnostic_update(
&mut self, &mut self,
server_id: LanguageServerId,
diagnostics: DiagnosticSet, diagnostics: DiagnosticSet,
lamport_timestamp: clock::Lamport, lamport_timestamp: clock::Lamport,
cx: &mut ModelContext<Self>, cx: &mut ModelContext<Self>,
) { ) {
if lamport_timestamp > self.diagnostics_timestamp { if lamport_timestamp > self.diagnostics_timestamp {
self.diagnostics = diagnostics; match self.diagnostics.binary_search_by_key(&server_id, |e| e.0) {
Err(ix) => self.diagnostics.insert(ix, (server_id, diagnostics)),
Ok(ix) => self.diagnostics[ix].1 = diagnostics,
};
self.diagnostics_timestamp = lamport_timestamp; self.diagnostics_timestamp = lamport_timestamp;
self.diagnostics_update_count += 1; self.diagnostics_update_count += 1;
self.text.lamport_clock.observe(lamport_timestamp); self.text.lamport_clock.observe(lamport_timestamp);
@ -2504,14 +2529,55 @@ impl BufferSnapshot {
) -> impl 'a + Iterator<Item = DiagnosticEntry<O>> ) -> impl 'a + Iterator<Item = DiagnosticEntry<O>>
where where
T: 'a + Clone + ToOffset, T: 'a + Clone + ToOffset,
O: 'a + FromAnchor, O: 'a + FromAnchor + Ord,
{ {
self.diagnostics.range(search_range, self, true, reversed) let mut iterators: Vec<_> = self
.diagnostics
.iter()
.map(|(_, collection)| {
collection
.range::<T, O>(search_range.clone(), self, true, reversed)
.peekable()
})
.collect();
std::iter::from_fn(move || {
let (next_ix, _) = iterators
.iter_mut()
.enumerate()
.flat_map(|(ix, iter)| Some((ix, iter.peek()?)))
.min_by(|(_, a), (_, b)| a.range.start.cmp(&b.range.start))?;
iterators[next_ix].next()
})
} }
pub fn diagnostic_groups(&self) -> Vec<DiagnosticGroup<Anchor>> { pub fn diagnostic_groups(
&self,
language_server_id: Option<LanguageServerId>,
) -> Vec<(LanguageServerId, DiagnosticGroup<Anchor>)> {
let mut groups = Vec::new(); let mut groups = Vec::new();
self.diagnostics.groups(&mut groups, self);
if let Some(language_server_id) = language_server_id {
if let Ok(ix) = self
.diagnostics
.binary_search_by_key(&language_server_id, |e| e.0)
{
self.diagnostics[ix]
.1
.groups(language_server_id, &mut groups, self);
}
} else {
for (language_server_id, diagnostics) in self.diagnostics.iter() {
diagnostics.groups(*language_server_id, &mut groups, self);
}
}
groups.sort_by(|(id_a, group_a), (id_b, group_b)| {
let a_start = &group_a.entries[group_a.primary_ix].range.start;
let b_start = &group_b.entries[group_b.primary_ix].range.start;
a_start.cmp(b_start, self).then_with(|| id_a.cmp(&id_b))
});
groups groups
} }
@ -2522,7 +2588,9 @@ impl BufferSnapshot {
where where
O: 'a + FromAnchor, O: 'a + FromAnchor,
{ {
self.diagnostics.group(group_id, self) self.diagnostics
.iter()
.flat_map(move |(_, set)| set.group(group_id, self))
} }
pub fn diagnostics_update_count(&self) -> usize { pub fn diagnostics_update_count(&self) -> usize {

2
crates/language/src/buffer_tests.rs
View File

@ -1866,7 +1866,7 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
buffer, buffer,
); );
log::info!("peer {} setting diagnostics: {:?}", replica_id, diagnostics); log::info!("peer {} setting diagnostics: {:?}", replica_id, diagnostics);
buffer.update_diagnostics(diagnostics, cx); buffer.update_diagnostics(LanguageServerId(0), diagnostics, cx);
}); });
mutation_count -= 1; mutation_count -= 1;
} }

26
crates/language/src/diagnostic_set.rs
View File

@ -1,5 +1,6 @@
use crate::Diagnostic; use crate::Diagnostic;
use collections::HashMap; use collections::HashMap;
use lsp::LanguageServerId;
use std::{ use std::{
cmp::{Ordering, Reverse}, cmp::{Ordering, Reverse},
iter, iter,
@ -129,7 +130,12 @@ impl DiagnosticSet {
}) })
} }
pub fn groups(&self, output: &mut Vec<DiagnosticGroup<Anchor>>, buffer: &text::BufferSnapshot) { pub fn groups(
&self,
language_server_id: LanguageServerId,
output: &mut Vec<(LanguageServerId, DiagnosticGroup<Anchor>)>,
buffer: &text::BufferSnapshot,
) {
let mut groups = HashMap::default(); let mut groups = HashMap::default();
for entry in self.diagnostics.iter() { for entry in self.diagnostics.iter() {
groups groups
@ -144,16 +150,22 @@ impl DiagnosticSet {
entries entries
.iter() .iter()
.position(|entry| entry.diagnostic.is_primary) .position(|entry| entry.diagnostic.is_primary)
.map(|primary_ix| DiagnosticGroup { .map(|primary_ix| {
entries, (
primary_ix, language_server_id,
DiagnosticGroup {
entries,
primary_ix,
},
)
}) })
})); }));
output[start_ix..].sort_unstable_by(|a, b| { output[start_ix..].sort_unstable_by(|(id_a, group_a), (id_b, group_b)| {
a.entries[a.primary_ix] group_a.entries[group_a.primary_ix]
.range .range
.start .start
.cmp(&b.entries[b.primary_ix].range.start, buffer) .cmp(&group_b.entries[group_b.primary_ix].range.start, buffer)
.then_with(|| id_a.cmp(&id_b))
}); });
} }

97
crates/language/src/language.rs
View File

@ -54,6 +54,7 @@ use futures::channel::mpsc;
pub use buffer::Operation; pub use buffer::Operation;
pub use buffer::*; pub use buffer::*;
pub use diagnostic_set::DiagnosticEntry; pub use diagnostic_set::DiagnosticEntry;
pub use lsp::LanguageServerId;
pub use outline::{Outline, OutlineItem}; pub use outline::{Outline, OutlineItem};
pub use tree_sitter::{Parser, Tree}; pub use tree_sitter::{Parser, Tree};
@ -414,7 +415,7 @@ 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<CachedLspAdapter>>, pub(crate) adapters: Vec<Arc<CachedLspAdapter>>,
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
fake_adapter: Option<( fake_adapter: Option<(
@ -492,7 +493,7 @@ struct AvailableLanguage {
path: &'static str, path: &'static str,
config: LanguageConfig, config: LanguageConfig,
grammar: tree_sitter::Language, grammar: tree_sitter::Language,
lsp_adapter: Option<Arc<dyn LspAdapter>>, lsp_adapters: Vec<Arc<dyn LspAdapter>>,
get_queries: fn(&str) -> LanguageQueries, get_queries: fn(&str) -> LanguageQueries,
} }
@ -513,6 +514,7 @@ pub struct LanguageRegistry {
} }
struct LanguageRegistryState { struct LanguageRegistryState {
next_language_server_id: usize,
languages: Vec<Arc<Language>>, languages: Vec<Arc<Language>>,
available_languages: Vec<AvailableLanguage>, available_languages: Vec<AvailableLanguage>,
next_available_language_id: AvailableLanguageId, next_available_language_id: AvailableLanguageId,
@ -522,11 +524,17 @@ struct LanguageRegistryState {
version: usize, version: usize,
} }
pub struct PendingLanguageServer {
pub server_id: LanguageServerId,
pub task: Task<Result<lsp::LanguageServer>>,
}
impl LanguageRegistry { impl LanguageRegistry {
pub fn new(login_shell_env_loaded: Task<()>) -> Self { pub fn new(login_shell_env_loaded: Task<()>) -> Self {
let (lsp_binary_statuses_tx, lsp_binary_statuses_rx) = async_broadcast::broadcast(16); let (lsp_binary_statuses_tx, lsp_binary_statuses_rx) = async_broadcast::broadcast(16);
Self { Self {
state: RwLock::new(LanguageRegistryState { state: RwLock::new(LanguageRegistryState {
next_language_server_id: 0,
languages: vec![PLAIN_TEXT.clone()], languages: vec![PLAIN_TEXT.clone()],
available_languages: Default::default(), available_languages: Default::default(),
next_available_language_id: 0, next_available_language_id: 0,
@ -558,7 +566,7 @@ impl LanguageRegistry {
path: &'static str, path: &'static str,
config: LanguageConfig, config: LanguageConfig,
grammar: tree_sitter::Language, grammar: tree_sitter::Language,
lsp_adapter: Option<Arc<dyn LspAdapter>>, lsp_adapters: Vec<Arc<dyn LspAdapter>>,
get_queries: fn(&str) -> LanguageQueries, get_queries: fn(&str) -> LanguageQueries,
) { ) {
let state = &mut *self.state.write(); let state = &mut *self.state.write();
@ -567,7 +575,7 @@ impl LanguageRegistry {
path, path,
config, config,
grammar, grammar,
lsp_adapter, lsp_adapters,
get_queries, get_queries,
}); });
} }
@ -590,12 +598,13 @@ impl LanguageRegistry {
state state
.available_languages .available_languages
.iter() .iter()
.filter_map(|l| l.lsp_adapter.clone()) .flat_map(|l| l.lsp_adapters.clone())
.chain( .chain(
state state
.languages .languages
.iter() .iter()
.filter_map(|l| l.adapter.as_ref().map(|a| a.adapter.clone())), .flat_map(|language| &language.adapters)
.map(|adapter| adapter.adapter.clone()),
) )
.collect::<Vec<_>>() .collect::<Vec<_>>()
}; };
@ -721,7 +730,7 @@ impl LanguageRegistry {
let queries = (language.get_queries)(&language.path); let queries = (language.get_queries)(&language.path);
let language = let language =
Language::new(language.config, Some(language.grammar)) Language::new(language.config, Some(language.grammar))
.with_lsp_adapter(language.lsp_adapter) .with_lsp_adapters(language.lsp_adapters)
.await; .await;
let name = language.name(); let name = language.name();
match language.with_queries(queries) { match language.with_queries(queries) {
@ -776,16 +785,15 @@ impl LanguageRegistry {
pub fn start_language_server( pub fn start_language_server(
self: &Arc<Self>, self: &Arc<Self>,
server_id: usize,
language: Arc<Language>, language: Arc<Language>,
adapter: Arc<CachedLspAdapter>,
root_path: Arc<Path>, root_path: Arc<Path>,
http_client: Arc<dyn HttpClient>, http_client: Arc<dyn HttpClient>,
cx: &mut AppContext, cx: &mut AppContext,
) -> Option<Task<Result<lsp::LanguageServer>>> { ) -> Option<PendingLanguageServer> {
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
if language.fake_adapter.is_some() { if language.fake_adapter.is_some() {
let language = language; let task = cx.spawn(|cx| async move {
return Some(cx.spawn(|cx| async move {
let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap(); let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
let (server, mut fake_server) = lsp::LanguageServer::fake( let (server, mut fake_server) = lsp::LanguageServer::fake(
fake_adapter.name.to_string(), fake_adapter.name.to_string(),
@ -810,7 +818,10 @@ impl LanguageRegistry {
}) })
.detach(); .detach();
Ok(server) Ok(server)
})); });
let server_id = self.state.write().next_language_server_id();
return Some(PendingLanguageServer { server_id, task });
} }
let download_dir = self let download_dir = self
@ -820,11 +831,16 @@ impl LanguageRegistry {
.log_err()?; .log_err()?;
let this = self.clone(); let this = self.clone();
let adapter = language.adapter.clone()?; let language = language.clone();
let http_client = http_client.clone();
let download_dir = download_dir.clone();
let root_path = root_path.clone();
let adapter = adapter.clone();
let lsp_binary_statuses = self.lsp_binary_statuses_tx.clone(); let lsp_binary_statuses = self.lsp_binary_statuses_tx.clone();
let login_shell_env_loaded = self.login_shell_env_loaded.clone(); let login_shell_env_loaded = self.login_shell_env_loaded.clone();
let server_id = self.state.write().next_language_server_id();
Some(cx.spawn(|cx| async move { let task = cx.spawn(|cx| async move {
login_shell_env_loaded.await; login_shell_env_loaded.await;
let mut lock = this.lsp_binary_paths.lock(); let mut lock = this.lsp_binary_paths.lock();
@ -856,7 +872,9 @@ impl LanguageRegistry {
)?; )?;
Ok(server) Ok(server)
})) });
Some(PendingLanguageServer { server_id, task })
} }
pub fn language_server_binary_statuses( pub fn language_server_binary_statuses(
@ -867,6 +885,10 @@ impl LanguageRegistry {
} }
impl LanguageRegistryState { impl LanguageRegistryState {
fn next_language_server_id(&mut self) -> LanguageServerId {
LanguageServerId(post_inc(&mut self.next_language_server_id))
}
fn add(&mut self, language: Arc<Language>) { fn add(&mut self, language: Arc<Language>) {
if let Some(theme) = self.theme.as_ref() { if let Some(theme) = self.theme.as_ref() {
language.set_theme(&theme.editor.syntax); language.set_theme(&theme.editor.syntax);
@ -974,15 +996,15 @@ impl Language {
highlight_map: Default::default(), highlight_map: Default::default(),
}) })
}), }),
adapter: None, adapters: Vec::new(),
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]
fake_adapter: None, fake_adapter: None,
} }
} }
pub fn lsp_adapter(&self) -> Option<Arc<CachedLspAdapter>> { pub fn lsp_adapters(&self) -> &[Arc<CachedLspAdapter>] {
self.adapter.clone() &self.adapters
} }
pub fn id(&self) -> Option<usize> { pub fn id(&self) -> Option<usize> {
@ -1209,9 +1231,9 @@ impl Language {
Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap() Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap()
} }
pub async fn with_lsp_adapter(mut self, lsp_adapter: Option<Arc<dyn LspAdapter>>) -> Self { pub async fn with_lsp_adapters(mut self, lsp_adapters: Vec<Arc<dyn LspAdapter>>) -> Self {
if let Some(adapter) = lsp_adapter { for adapter in lsp_adapters {
self.adapter = Some(CachedLspAdapter::new(adapter).await); self.adapters.push(CachedLspAdapter::new(adapter).await);
} }
self self
} }
@ -1224,7 +1246,7 @@ impl Language {
let (servers_tx, servers_rx) = mpsc::unbounded(); let (servers_tx, servers_rx) = mpsc::unbounded();
self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone())); self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
let adapter = CachedLspAdapter::new(Arc::new(fake_lsp_adapter)).await; let adapter = CachedLspAdapter::new(Arc::new(fake_lsp_adapter)).await;
self.adapter = Some(adapter); self.adapters = vec![adapter];
servers_rx servers_rx
} }
@ -1233,28 +1255,31 @@ impl Language {
} }
pub async fn disk_based_diagnostic_sources(&self) -> &[String] { pub async fn disk_based_diagnostic_sources(&self) -> &[String] {
match self.adapter.as_ref() { match self.adapters.first().as_ref() {
Some(adapter) => &adapter.disk_based_diagnostic_sources, Some(adapter) => &adapter.disk_based_diagnostic_sources,
None => &[], None => &[],
} }
} }
pub async fn disk_based_diagnostics_progress_token(&self) -> Option<&str> { pub async fn disk_based_diagnostics_progress_token(&self) -> Option<&str> {
if let Some(adapter) = self.adapter.as_ref() { for adapter in &self.adapters {
adapter.disk_based_diagnostics_progress_token.as_deref() let token = adapter.disk_based_diagnostics_progress_token.as_deref();
} else { if token.is_some() {
None return token;
}
} }
None
} }
pub async fn process_diagnostics(&self, diagnostics: &mut lsp::PublishDiagnosticsParams) { pub async fn process_diagnostics(&self, diagnostics: &mut lsp::PublishDiagnosticsParams) {
if let Some(processor) = self.adapter.as_ref() { for adapter in &self.adapters {
processor.process_diagnostics(diagnostics).await; adapter.process_diagnostics(diagnostics).await;
} }
} }
pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp::CompletionItem) { pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp::CompletionItem) {
if let Some(adapter) = self.adapter.as_ref() { for adapter in &self.adapters {
adapter.process_completion(completion).await; adapter.process_completion(completion).await;
} }
} }
@ -1263,7 +1288,8 @@ impl Language {
self: &Arc<Self>, self: &Arc<Self>,
completion: &lsp::CompletionItem, completion: &lsp::CompletionItem,
) -> Option<CodeLabel> { ) -> Option<CodeLabel> {
self.adapter self.adapters
.first()
.as_ref()? .as_ref()?
.label_for_completion(completion, self) .label_for_completion(completion, self)
.await .await
@ -1274,7 +1300,8 @@ impl Language {
name: &str, name: &str,
kind: lsp::SymbolKind, kind: lsp::SymbolKind,
) -> Option<CodeLabel> { ) -> Option<CodeLabel> {
self.adapter self.adapters
.first()
.as_ref()? .as_ref()?
.label_for_symbol(name, kind, self) .label_for_symbol(name, kind, self)
.await .await
@ -1559,7 +1586,7 @@ mod tests {
..Default::default() ..Default::default()
}, },
tree_sitter_javascript::language(), tree_sitter_javascript::language(),
None, vec![],
|_| Default::default(), |_| Default::default(),
); );
@ -1595,7 +1622,7 @@ mod tests {
..Default::default() ..Default::default()
}, },
tree_sitter_json::language(), tree_sitter_json::language(),
None, vec![],
|_| Default::default(), |_| Default::default(),
); );
languages.register( languages.register(
@ -1606,7 +1633,7 @@ mod tests {
..Default::default() ..Default::default()
}, },
tree_sitter_rust::language(), tree_sitter_rust::language(),
None, vec![],
|_| Default::default(), |_| Default::default(),
); );
assert_eq!( assert_eq!(

15
crates/language/src/proto.rs
View File

@ -4,7 +4,7 @@ use crate::{
}; };
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use clock::ReplicaId; use clock::ReplicaId;
use lsp::DiagnosticSeverity; use lsp::{DiagnosticSeverity, LanguageServerId};
use rpc::proto; use rpc::proto;
use std::{ops::Range, sync::Arc}; use std::{ops::Range, sync::Arc};
use text::*; use text::*;
@ -40,6 +40,7 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
crate::Operation::Buffer(text::Operation::Edit(edit)) => { crate::Operation::Buffer(text::Operation::Edit(edit)) => {
proto::operation::Variant::Edit(serialize_edit_operation(edit)) proto::operation::Variant::Edit(serialize_edit_operation(edit))
} }
crate::Operation::Buffer(text::Operation::Undo { crate::Operation::Buffer(text::Operation::Undo {
undo, undo,
lamport_timestamp, lamport_timestamp,
@ -58,6 +59,7 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
}) })
.collect(), .collect(),
}), }),
crate::Operation::UpdateSelections { crate::Operation::UpdateSelections {
selections, selections,
line_mode, line_mode,
@ -70,14 +72,18 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
line_mode: *line_mode, line_mode: *line_mode,
cursor_shape: serialize_cursor_shape(cursor_shape) as i32, cursor_shape: serialize_cursor_shape(cursor_shape) as i32,
}), }),
crate::Operation::UpdateDiagnostics { crate::Operation::UpdateDiagnostics {
diagnostics,
lamport_timestamp, lamport_timestamp,
server_id,
diagnostics,
} => proto::operation::Variant::UpdateDiagnostics(proto::UpdateDiagnostics { } => proto::operation::Variant::UpdateDiagnostics(proto::UpdateDiagnostics {
replica_id: lamport_timestamp.replica_id as u32, replica_id: lamport_timestamp.replica_id as u32,
lamport_timestamp: lamport_timestamp.value, lamport_timestamp: lamport_timestamp.value,
server_id: server_id.0 as u64,
diagnostics: serialize_diagnostics(diagnostics.iter()), diagnostics: serialize_diagnostics(diagnostics.iter()),
}), }),
crate::Operation::UpdateCompletionTriggers { crate::Operation::UpdateCompletionTriggers {
triggers, triggers,
lamport_timestamp, lamport_timestamp,
@ -267,11 +273,12 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operati
} }
proto::operation::Variant::UpdateDiagnostics(message) => { proto::operation::Variant::UpdateDiagnostics(message) => {
crate::Operation::UpdateDiagnostics { crate::Operation::UpdateDiagnostics {
diagnostics: deserialize_diagnostics(message.diagnostics),
lamport_timestamp: clock::Lamport { lamport_timestamp: clock::Lamport {
replica_id: message.replica_id as ReplicaId, replica_id: message.replica_id as ReplicaId,
value: message.lamport_timestamp, value: message.lamport_timestamp,
}, },
server_id: LanguageServerId(message.server_id as usize),
diagnostics: deserialize_diagnostics(message.diagnostics),
} }
} }
proto::operation::Variant::UpdateCompletionTriggers(message) => { proto::operation::Variant::UpdateCompletionTriggers(message) => {
@ -462,6 +469,7 @@ pub async fn deserialize_completion(
pub fn serialize_code_action(action: &CodeAction) -> proto::CodeAction { pub fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
proto::CodeAction { proto::CodeAction {
server_id: action.server_id.0 as u64,
start: Some(serialize_anchor(&action.range.start)), start: Some(serialize_anchor(&action.range.start)),
end: Some(serialize_anchor(&action.range.end)), end: Some(serialize_anchor(&action.range.end)),
lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(), lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
@ -479,6 +487,7 @@ pub fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction>
.ok_or_else(|| anyhow!("invalid end"))?; .ok_or_else(|| anyhow!("invalid end"))?;
let lsp_action = serde_json::from_slice(&action.lsp_action)?; let lsp_action = serde_json::from_slice(&action.lsp_action)?;
Ok(CodeAction { Ok(CodeAction {
server_id: LanguageServerId(action.server_id as usize),
range: start..end, range: start..end,
lsp_action, lsp_action,
}) })

23
crates/lsp/src/lsp.rs
View File

@ -16,6 +16,7 @@ use smol::{
process::{self, Child}, process::{self, Child},
}; };
use std::{ use std::{
fmt,
future::Future, future::Future,
io::Write, io::Write,
path::PathBuf, path::PathBuf,
@ -35,7 +36,7 @@ type NotificationHandler = Box<dyn Send + FnMut(Option<usize>, &str, AsyncAppCon
type ResponseHandler = Box<dyn Send + FnOnce(Result<&str, Error>)>; type ResponseHandler = Box<dyn Send + FnOnce(Result<&str, Error>)>;
pub struct LanguageServer { pub struct LanguageServer {
server_id: usize, server_id: LanguageServerId,
next_id: AtomicUsize, next_id: AtomicUsize,
outbound_tx: channel::Sender<Vec<u8>>, outbound_tx: channel::Sender<Vec<u8>>,
name: String, name: String,
@ -51,6 +52,10 @@ pub struct LanguageServer {
_server: Option<Child>, _server: Option<Child>,
} }
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct LanguageServerId(pub usize);
pub struct Subscription { pub struct Subscription {
method: &'static str, method: &'static str,
notification_handlers: Arc<Mutex<HashMap<&'static str, NotificationHandler>>>, notification_handlers: Arc<Mutex<HashMap<&'static str, NotificationHandler>>>,
@ -107,7 +112,7 @@ struct Error {
impl LanguageServer { impl LanguageServer {
pub fn new<T: AsRef<std::ffi::OsStr>>( pub fn new<T: AsRef<std::ffi::OsStr>>(
server_id: usize, server_id: LanguageServerId,
binary_path: &Path, binary_path: &Path,
arguments: &[T], arguments: &[T],
root_path: &Path, root_path: &Path,
@ -158,7 +163,7 @@ impl LanguageServer {
} }
fn new_internal<Stdin, Stdout, F>( fn new_internal<Stdin, Stdout, F>(
server_id: usize, server_id: LanguageServerId,
stdin: Stdin, stdin: Stdin,
stdout: Stdout, stdout: Stdout,
server: Option<Child>, server: Option<Child>,
@ -581,7 +586,7 @@ impl LanguageServer {
&self.capabilities &self.capabilities
} }
pub fn server_id(&self) -> usize { pub fn server_id(&self) -> LanguageServerId {
self.server_id self.server_id
} }
@ -685,6 +690,12 @@ impl Subscription {
} }
} }
impl fmt::Display for LanguageServerId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl Drop for Subscription { impl Drop for Subscription {
fn drop(&mut self) { fn drop(&mut self) {
self.notification_handlers.lock().remove(self.method); self.notification_handlers.lock().remove(self.method);
@ -720,7 +731,7 @@ impl LanguageServer {
let (notifications_tx, notifications_rx) = channel::unbounded(); let (notifications_tx, notifications_rx) = channel::unbounded();
let server = Self::new_internal( let server = Self::new_internal(
0, LanguageServerId(0),
stdin_writer, stdin_writer,
stdout_reader, stdout_reader,
None, None,
@ -731,7 +742,7 @@ impl LanguageServer {
); );
let fake = FakeLanguageServer { let fake = FakeLanguageServer {
server: Arc::new(Self::new_internal( server: Arc::new(Self::new_internal(
0, LanguageServerId(0),
stdout_writer, stdout_writer,
stdin_reader, stdin_reader,
None, None,

34
crates/project/src/lsp_command.rs
View File

@ -12,7 +12,7 @@ use language::{
range_from_lsp, range_to_lsp, Anchor, Bias, Buffer, CachedLspAdapter, CharKind, CodeAction, range_from_lsp, range_to_lsp, Anchor, Bias, Buffer, CachedLspAdapter, CharKind, CodeAction,
Completion, OffsetRangeExt, PointUtf16, ToOffset, ToPointUtf16, Unclipped, Completion, OffsetRangeExt, PointUtf16, ToOffset, ToPointUtf16, Unclipped,
}; };
use lsp::{DocumentHighlightKind, LanguageServer, ServerCapabilities}; use lsp::{DocumentHighlightKind, LanguageServer, LanguageServerId, ServerCapabilities};
use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag}; use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
use std::{cmp::Reverse, ops::Range, path::Path, sync::Arc}; use std::{cmp::Reverse, ops::Range, path::Path, sync::Arc};
@ -33,21 +33,25 @@ pub(crate) trait LspCommand: 'static + Sized {
language_server: &Arc<LanguageServer>, language_server: &Arc<LanguageServer>,
cx: &AppContext, cx: &AppContext,
) -> <Self::LspRequest as lsp::request::Request>::Params; ) -> <Self::LspRequest as lsp::request::Request>::Params;
async fn response_from_lsp( async fn response_from_lsp(
self, self,
message: <Self::LspRequest as lsp::request::Request>::Result, message: <Self::LspRequest as lsp::request::Request>::Result,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Self::Response>; ) -> Result<Self::Response>;
fn to_proto(&self, project_id: u64, buffer: &Buffer) -> Self::ProtoRequest; fn to_proto(&self, project_id: u64, buffer: &Buffer) -> Self::ProtoRequest;
async fn from_proto( async fn from_proto(
message: Self::ProtoRequest, message: Self::ProtoRequest,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Self>; ) -> Result<Self>;
fn response_to_proto( fn response_to_proto(
response: Self::Response, response: Self::Response,
project: &mut Project, project: &mut Project,
@ -55,6 +59,7 @@ pub(crate) trait LspCommand: 'static + Sized {
buffer_version: &clock::Global, buffer_version: &clock::Global,
cx: &mut AppContext, cx: &mut AppContext,
) -> <Self::ProtoRequest as proto::RequestMessage>::Response; ) -> <Self::ProtoRequest as proto::RequestMessage>::Response;
async fn response_from_proto( async fn response_from_proto(
self, self,
message: <Self::ProtoRequest as proto::RequestMessage>::Response, message: <Self::ProtoRequest as proto::RequestMessage>::Response,
@ -62,6 +67,7 @@ pub(crate) trait LspCommand: 'static + Sized {
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Self::Response>; ) -> Result<Self::Response>;
fn buffer_id_from_proto(message: &Self::ProtoRequest) -> u64; fn buffer_id_from_proto(message: &Self::ProtoRequest) -> u64;
} }
@ -137,6 +143,7 @@ impl LspCommand for PrepareRename {
message: Option<lsp::PrepareRenameResponse>, message: Option<lsp::PrepareRenameResponse>,
_: ModelHandle<Project>, _: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
_: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Option<Range<Anchor>>> { ) -> Result<Option<Range<Anchor>>> {
buffer.read_with(&cx, |buffer, _| { buffer.read_with(&cx, |buffer, _| {
@ -263,10 +270,12 @@ impl LspCommand for PerformRename {
message: Option<lsp::WorkspaceEdit>, message: Option<lsp::WorkspaceEdit>,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
mut cx: AsyncAppContext, mut cx: AsyncAppContext,
) -> Result<ProjectTransaction> { ) -> Result<ProjectTransaction> {
if let Some(edit) = message { if let Some(edit) = message {
let (lsp_adapter, lsp_server) = language_server_for_buffer(&project, &buffer, &mut cx)?; let (lsp_adapter, lsp_server) =
language_server_for_buffer(&project, &buffer, server_id, &mut cx)?;
Project::deserialize_workspace_edit( Project::deserialize_workspace_edit(
project, project,
edit, edit,
@ -380,9 +389,10 @@ impl LspCommand for GetDefinition {
message: Option<lsp::GotoDefinitionResponse>, message: Option<lsp::GotoDefinitionResponse>,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Vec<LocationLink>> { ) -> Result<Vec<LocationLink>> {
location_links_from_lsp(message, project, buffer, cx).await location_links_from_lsp(message, project, buffer, server_id, cx).await
} }
fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetDefinition { fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetDefinition {
@ -472,9 +482,10 @@ impl LspCommand for GetTypeDefinition {
message: Option<lsp::GotoTypeDefinitionResponse>, message: Option<lsp::GotoTypeDefinitionResponse>,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Vec<LocationLink>> { ) -> Result<Vec<LocationLink>> {
location_links_from_lsp(message, project, buffer, cx).await location_links_from_lsp(message, project, buffer, server_id, cx).await
} }
fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetTypeDefinition { fn to_proto(&self, project_id: u64, buffer: &Buffer) -> proto::GetTypeDefinition {
@ -537,12 +548,13 @@ impl LspCommand for GetTypeDefinition {
fn language_server_for_buffer( fn language_server_for_buffer(
project: &ModelHandle<Project>, project: &ModelHandle<Project>,
buffer: &ModelHandle<Buffer>, buffer: &ModelHandle<Buffer>,
server_id: LanguageServerId,
cx: &mut AsyncAppContext, cx: &mut AsyncAppContext,
) -> Result<(Arc<CachedLspAdapter>, Arc<LanguageServer>)> { ) -> Result<(Arc<CachedLspAdapter>, Arc<LanguageServer>)> {
project project
.read_with(cx, |project, cx| { .read_with(cx, |project, cx| {
project project
.language_server_for_buffer(buffer.read(cx), cx) .language_server_for_buffer(buffer.read(cx), server_id, cx)
.map(|(adapter, server)| (adapter.clone(), server.clone())) .map(|(adapter, server)| (adapter.clone(), server.clone()))
}) })
.ok_or_else(|| anyhow!("no language server found for buffer")) .ok_or_else(|| anyhow!("no language server found for buffer"))
@ -614,6 +626,7 @@ async fn location_links_from_lsp(
message: Option<lsp::GotoDefinitionResponse>, message: Option<lsp::GotoDefinitionResponse>,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
mut cx: AsyncAppContext, mut cx: AsyncAppContext,
) -> Result<Vec<LocationLink>> { ) -> Result<Vec<LocationLink>> {
let message = match message { let message = match message {
@ -642,7 +655,8 @@ async fn location_links_from_lsp(
} }
} }
let (lsp_adapter, language_server) = language_server_for_buffer(&project, &buffer, &mut cx)?; let (lsp_adapter, language_server) =
language_server_for_buffer(&project, &buffer, server_id, &mut cx)?;
let mut definitions = Vec::new(); let mut definitions = Vec::new();
for (origin_range, target_uri, target_range) in unresolved_links { for (origin_range, target_uri, target_range) in unresolved_links {
let target_buffer_handle = project let target_buffer_handle = project
@ -756,11 +770,12 @@ impl LspCommand for GetReferences {
locations: Option<Vec<lsp::Location>>, locations: Option<Vec<lsp::Location>>,
project: ModelHandle<Project>, project: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
server_id: LanguageServerId,
mut cx: AsyncAppContext, mut cx: AsyncAppContext,
) -> Result<Vec<Location>> { ) -> Result<Vec<Location>> {
let mut references = Vec::new(); let mut references = Vec::new();
let (lsp_adapter, language_server) = let (lsp_adapter, language_server) =
language_server_for_buffer(&project, &buffer, &mut cx)?; language_server_for_buffer(&project, &buffer, server_id, &mut cx)?;
if let Some(locations) = locations { if let Some(locations) = locations {
for lsp_location in locations { for lsp_location in locations {
@ -917,6 +932,7 @@ impl LspCommand for GetDocumentHighlights {
lsp_highlights: Option<Vec<lsp::DocumentHighlight>>, lsp_highlights: Option<Vec<lsp::DocumentHighlight>>,
_: ModelHandle<Project>, _: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
_: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Vec<DocumentHighlight>> { ) -> Result<Vec<DocumentHighlight>> {
buffer.read_with(&cx, |buffer, _| { buffer.read_with(&cx, |buffer, _| {
@ -1062,6 +1078,7 @@ impl LspCommand for GetHover {
message: Option<lsp::Hover>, message: Option<lsp::Hover>,
_: ModelHandle<Project>, _: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
_: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Self::Response> { ) -> Result<Self::Response> {
Ok(message.and_then(|hover| { Ok(message.and_then(|hover| {
@ -1283,6 +1300,7 @@ impl LspCommand for GetCompletions {
completions: Option<lsp::CompletionResponse>, completions: Option<lsp::CompletionResponse>,
_: ModelHandle<Project>, _: ModelHandle<Project>,
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
_: LanguageServerId,
cx: AsyncAppContext, cx: AsyncAppContext,
) -> Result<Vec<Completion>> { ) -> Result<Vec<Completion>> {
let completions = if let Some(completions) = completions { let completions = if let Some(completions) = completions {
@ -1502,6 +1520,7 @@ impl LspCommand for GetCodeActions {
actions: Option<lsp::CodeActionResponse>, actions: Option<lsp::CodeActionResponse>,
_: ModelHandle<Project>, _: ModelHandle<Project>,
_: ModelHandle<Buffer>, _: ModelHandle<Buffer>,
server_id: LanguageServerId,
_: AsyncAppContext, _: AsyncAppContext,
) -> Result<Vec<CodeAction>> { ) -> Result<Vec<CodeAction>> {
Ok(actions Ok(actions
@ -1510,6 +1529,7 @@ impl LspCommand for GetCodeActions {
.filter_map(|entry| { .filter_map(|entry| {
if let lsp::CodeActionOrCommand::CodeAction(lsp_action) = entry { if let lsp::CodeActionOrCommand::CodeAction(lsp_action) = entry {
Some(CodeAction { Some(CodeAction {
server_id,
range: self.range.clone(), range: self.range.clone(),
lsp_action, lsp_action,
}) })

1171
crates/project/src/project.rs
View File

File diff suppressed because it is too large Load Diff

97
crates/project/src/project_tests.rs
View File

@ -303,6 +303,7 @@ async fn test_managing_language_servers(
rust_buffer2.update(cx, |buffer, cx| { rust_buffer2.update(cx, |buffer, cx| {
buffer.update_diagnostics( buffer.update_diagnostics(
LanguageServerId(0),
DiagnosticSet::from_sorted_entries( DiagnosticSet::from_sorted_entries(
vec![DiagnosticEntry { vec![DiagnosticEntry {
diagnostic: Default::default(), diagnostic: Default::default(),
@ -399,7 +400,7 @@ async fn test_managing_language_servers(
.text_document, .text_document,
lsp::TextDocumentItem { lsp::TextDocumentItem {
uri: lsp::Url::from_file_path("/the-root/test.rs").unwrap(), uri: lsp::Url::from_file_path("/the-root/test.rs").unwrap(),
version: 1, version: 0,
text: rust_buffer.read_with(cx, |buffer, _| buffer.text()), text: rust_buffer.read_with(cx, |buffer, _| buffer.text()),
language_id: Default::default() language_id: Default::default()
} }
@ -426,7 +427,7 @@ async fn test_managing_language_servers(
}, },
lsp::TextDocumentItem { lsp::TextDocumentItem {
uri: lsp::Url::from_file_path("/the-root/test3.json").unwrap(), uri: lsp::Url::from_file_path("/the-root/test3.json").unwrap(),
version: 1, version: 0,
text: rust_buffer2.read_with(cx, |buffer, _| buffer.text()), text: rust_buffer2.read_with(cx, |buffer, _| buffer.text()),
language_id: Default::default() language_id: Default::default()
} }
@ -581,7 +582,7 @@ async fn test_single_file_worktrees_diagnostics(cx: &mut gpui::TestAppContext) {
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project project
.update_diagnostics( .update_diagnostics(
0, LanguageServerId(0),
lsp::PublishDiagnosticsParams { lsp::PublishDiagnosticsParams {
uri: Url::from_file_path("/dir/a.rs").unwrap(), uri: Url::from_file_path("/dir/a.rs").unwrap(),
version: None, version: None,
@ -598,7 +599,7 @@ async fn test_single_file_worktrees_diagnostics(cx: &mut gpui::TestAppContext) {
.unwrap(); .unwrap();
project project
.update_diagnostics( .update_diagnostics(
0, LanguageServerId(0),
lsp::PublishDiagnosticsParams { lsp::PublishDiagnosticsParams {
uri: Url::from_file_path("/dir/b.rs").unwrap(), uri: Url::from_file_path("/dir/b.rs").unwrap(),
version: None, version: None,
@ -674,7 +675,7 @@ async fn test_hidden_worktrees_diagnostics(cx: &mut gpui::TestAppContext) {
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project project
.update_diagnostics( .update_diagnostics(
0, LanguageServerId(0),
lsp::PublishDiagnosticsParams { lsp::PublishDiagnosticsParams {
uri: Url::from_file_path("/root/other.rs").unwrap(), uri: Url::from_file_path("/root/other.rs").unwrap(),
version: None, version: None,
@ -766,7 +767,7 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiskBasedDiagnosticsStarted { Event::DiskBasedDiagnosticsStarted {
language_server_id: 0, language_server_id: LanguageServerId(0),
} }
); );
@ -783,7 +784,7 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiagnosticsUpdated { Event::DiagnosticsUpdated {
language_server_id: 0, language_server_id: LanguageServerId(0),
path: (worktree_id, Path::new("a.rs")).into() path: (worktree_id, Path::new("a.rs")).into()
} }
); );
@ -792,7 +793,7 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiskBasedDiagnosticsFinished { Event::DiskBasedDiagnosticsFinished {
language_server_id: 0 language_server_id: LanguageServerId(0)
} }
); );
@ -830,7 +831,7 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiagnosticsUpdated { Event::DiagnosticsUpdated {
language_server_id: 0, language_server_id: LanguageServerId(0),
path: (worktree_id, Path::new("a.rs")).into() path: (worktree_id, Path::new("a.rs")).into()
} }
); );
@ -891,7 +892,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiskBasedDiagnosticsStarted { Event::DiskBasedDiagnosticsStarted {
language_server_id: 1 language_server_id: LanguageServerId(1)
} }
); );
project.read_with(cx, |project, _| { project.read_with(cx, |project, _| {
@ -899,7 +900,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
project project
.language_servers_running_disk_based_diagnostics() .language_servers_running_disk_based_diagnostics()
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
[1] [LanguageServerId(1)]
); );
}); });
@ -909,7 +910,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
assert_eq!( assert_eq!(
events.next().await.unwrap(), events.next().await.unwrap(),
Event::DiskBasedDiagnosticsFinished { Event::DiskBasedDiagnosticsFinished {
language_server_id: 1 language_server_id: LanguageServerId(1)
} }
); );
project.read_with(cx, |project, _| { project.read_with(cx, |project, _| {
@ -917,7 +918,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
project project
.language_servers_running_disk_based_diagnostics() .language_servers_running_disk_based_diagnostics()
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
[0; 0] [LanguageServerId(0); 0]
); );
}); });
} }
@ -1402,6 +1403,8 @@ async fn test_empty_diagnostic_ranges(cx: &mut gpui::TestAppContext) {
project project
.update_buffer_diagnostics( .update_buffer_diagnostics(
&buffer, &buffer,
LanguageServerId(0),
None,
vec![ vec![
DiagnosticEntry { DiagnosticEntry {
range: Unclipped(PointUtf16::new(0, 10))..Unclipped(PointUtf16::new(0, 10)), range: Unclipped(PointUtf16::new(0, 10))..Unclipped(PointUtf16::new(0, 10)),
@ -1420,7 +1423,6 @@ async fn test_empty_diagnostic_ranges(cx: &mut gpui::TestAppContext) {
}, },
}, },
], ],
None,
cx, cx,
) )
.unwrap(); .unwrap();
@ -1447,6 +1449,64 @@ async fn test_empty_diagnostic_ranges(cx: &mut gpui::TestAppContext) {
}); });
} }
#[gpui::test]
async fn test_diagnostics_from_multiple_language_servers(cx: &mut gpui::TestAppContext) {
println!("hello from stdout");
eprintln!("hello from stderr");
cx.foreground().forbid_parking();
let fs = FakeFs::new(cx.background());
fs.insert_tree("/dir", json!({ "a.rs": "one two three" }))
.await;
let project = Project::test(fs, ["/dir".as_ref()], cx).await;
project.update(cx, |project, cx| {
project
.update_diagnostic_entries(
LanguageServerId(0),
Path::new("/dir/a.rs").to_owned(),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(0, 0))..Unclipped(PointUtf16::new(0, 3)),
diagnostic: Diagnostic {
severity: DiagnosticSeverity::ERROR,
is_primary: true,
message: "syntax error a1".to_string(),
..Default::default()
},
}],
cx,
)
.unwrap();
project
.update_diagnostic_entries(
LanguageServerId(1),
Path::new("/dir/a.rs").to_owned(),
None,
vec![DiagnosticEntry {
range: Unclipped(PointUtf16::new(0, 0))..Unclipped(PointUtf16::new(0, 3)),
diagnostic: Diagnostic {
severity: DiagnosticSeverity::ERROR,
is_primary: true,
message: "syntax error b1".to_string(),
..Default::default()
},
}],
cx,
)
.unwrap();
assert_eq!(
project.diagnostic_summary(cx),
DiagnosticSummary {
error_count: 2,
warning_count: 0,
}
);
});
}
#[gpui::test] #[gpui::test]
async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) { async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
cx.foreground().forbid_parking(); cx.foreground().forbid_parking();
@ -1573,6 +1633,7 @@ async fn test_edits_from_lsp_with_past_version(cx: &mut gpui::TestAppContext) {
new_text: "".into(), new_text: "".into(),
}, },
], ],
LanguageServerId(0),
Some(lsp_document_version), Some(lsp_document_version),
cx, cx,
) )
@ -1667,6 +1728,7 @@ async fn test_edits_from_lsp_with_edits_on_adjacent_lines(cx: &mut gpui::TestApp
new_text: "".into(), new_text: "".into(),
}, },
], ],
LanguageServerId(0),
None, None,
cx, cx,
) )
@ -1770,6 +1832,7 @@ async fn test_invalid_edits_from_lsp(cx: &mut gpui::TestAppContext) {
.unindent(), .unindent(),
}, },
], ],
LanguageServerId(0),
None, None,
cx, cx,
) )
@ -2258,7 +2321,7 @@ async fn test_save_as(cx: &mut gpui::TestAppContext) {
..Default::default() ..Default::default()
}, },
tree_sitter_rust::language(), tree_sitter_rust::language(),
None, vec![],
|_| Default::default(), |_| Default::default(),
); );
@ -2948,7 +3011,9 @@ async fn test_grouped_diagnostics(cx: &mut gpui::TestAppContext) {
}; };
project project
.update(cx, |p, cx| p.update_diagnostics(0, message, &[], cx)) .update(cx, |p, cx| {
p.update_diagnostics(LanguageServerId(0), message, &[], cx)
})
.unwrap(); .unwrap();
let buffer = buffer.read_with(cx, |buffer, _| buffer.snapshot()); let buffer = buffer.read_with(cx, |buffer, _| buffer.snapshot());

107
crates/project/src/worktree.rs
View File

@ -26,6 +26,7 @@ use language::{
}, },
Buffer, DiagnosticEntry, File as _, PointUtf16, Rope, RopeFingerprint, Unclipped, Buffer, DiagnosticEntry, File as _, PointUtf16, Rope, RopeFingerprint, Unclipped,
}; };
use lsp::LanguageServerId;
use parking_lot::Mutex; use parking_lot::Mutex;
use postage::{ use postage::{
barrier, barrier,
@ -50,7 +51,7 @@ use std::{
}, },
time::{Duration, SystemTime}, time::{Duration, SystemTime},
}; };
use sum_tree::{Bias, Edit, SeekTarget, SumTree, TreeMap, TreeSet}; use sum_tree::{Bias, Edit, SeekTarget, SumTree, TreeSet};
use util::{paths::HOME, ResultExt, TryFutureExt}; use util::{paths::HOME, ResultExt, TryFutureExt};
#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)] #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
@ -67,8 +68,14 @@ pub struct LocalWorktree {
is_scanning: (watch::Sender<bool>, watch::Receiver<bool>), is_scanning: (watch::Sender<bool>, watch::Receiver<bool>),
_background_scanner_task: Task<()>, _background_scanner_task: Task<()>,
share: Option<ShareState>, share: Option<ShareState>,
diagnostics: HashMap<Arc<Path>, Vec<DiagnosticEntry<Unclipped<PointUtf16>>>>, diagnostics: HashMap<
diagnostic_summaries: TreeMap<PathKey, DiagnosticSummary>, Arc<Path>,
Vec<(
LanguageServerId,
Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
)>,
>,
diagnostic_summaries: HashMap<Arc<Path>, HashMap<LanguageServerId, DiagnosticSummary>>,
client: Arc<Client>, client: Arc<Client>,
fs: Arc<dyn Fs>, fs: Arc<dyn Fs>,
visible: bool, visible: bool,
@ -82,7 +89,7 @@ pub struct RemoteWorktree {
updates_tx: Option<UnboundedSender<proto::UpdateWorktree>>, updates_tx: Option<UnboundedSender<proto::UpdateWorktree>>,
snapshot_subscriptions: VecDeque<(usize, oneshot::Sender<()>)>, snapshot_subscriptions: VecDeque<(usize, oneshot::Sender<()>)>,
replica_id: ReplicaId, replica_id: ReplicaId,
diagnostic_summaries: TreeMap<PathKey, DiagnosticSummary>, diagnostic_summaries: HashMap<Arc<Path>, HashMap<LanguageServerId, DiagnosticSummary>>,
visible: bool, visible: bool,
disconnected: bool, disconnected: bool,
} }
@ -463,13 +470,17 @@ impl Worktree {
pub fn diagnostic_summaries( pub fn diagnostic_summaries(
&self, &self,
) -> impl Iterator<Item = (Arc<Path>, DiagnosticSummary)> + '_ { ) -> impl Iterator<Item = (Arc<Path>, LanguageServerId, DiagnosticSummary)> + '_ {
match self { match self {
Worktree::Local(worktree) => &worktree.diagnostic_summaries, Worktree::Local(worktree) => &worktree.diagnostic_summaries,
Worktree::Remote(worktree) => &worktree.diagnostic_summaries, Worktree::Remote(worktree) => &worktree.diagnostic_summaries,
} }
.iter() .iter()
.map(|(path, summary)| (path.0.clone(), *summary)) .flat_map(|(path, summaries)| {
summaries
.iter()
.map(move |(&server_id, &summary)| (path.clone(), server_id, summary))
})
} }
pub fn abs_path(&self) -> Arc<Path> { pub fn abs_path(&self) -> Arc<Path> {
@ -514,31 +525,54 @@ impl LocalWorktree {
pub fn diagnostics_for_path( pub fn diagnostics_for_path(
&self, &self,
path: &Path, path: &Path,
) -> Option<Vec<DiagnosticEntry<Unclipped<PointUtf16>>>> { ) -> Vec<(
self.diagnostics.get(path).cloned() LanguageServerId,
Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
)> {
self.diagnostics.get(path).cloned().unwrap_or_default()
} }
pub fn update_diagnostics( pub fn update_diagnostics(
&mut self, &mut self,
language_server_id: usize, server_id: LanguageServerId,
worktree_path: Arc<Path>, worktree_path: Arc<Path>,
diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>, diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
_: &mut ModelContext<Worktree>, _: &mut ModelContext<Worktree>,
) -> Result<bool> { ) -> Result<bool> {
self.diagnostics.remove(&worktree_path); let summaries_by_server_id = self
let old_summary = self
.diagnostic_summaries .diagnostic_summaries
.remove(&PathKey(worktree_path.clone())) .entry(worktree_path.clone())
.or_default();
let old_summary = summaries_by_server_id
.remove(&server_id)
.unwrap_or_default(); .unwrap_or_default();
let new_summary = DiagnosticSummary::new(language_server_id, &diagnostics);
if !new_summary.is_empty() { let new_summary = DiagnosticSummary::new(&diagnostics);
self.diagnostic_summaries if new_summary.is_empty() {
.insert(PathKey(worktree_path.clone()), new_summary); if let Some(diagnostics_by_server_id) = self.diagnostics.get_mut(&worktree_path) {
self.diagnostics.insert(worktree_path.clone(), diagnostics); if let Ok(ix) = diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
diagnostics_by_server_id.remove(ix);
}
if diagnostics_by_server_id.is_empty() {
self.diagnostics.remove(&worktree_path);
}
}
} else {
summaries_by_server_id.insert(server_id, new_summary);
let diagnostics_by_server_id =
self.diagnostics.entry(worktree_path.clone()).or_default();
match diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
Ok(ix) => {
diagnostics_by_server_id[ix] = (server_id, diagnostics);
}
Err(ix) => {
diagnostics_by_server_id.insert(ix, (server_id, diagnostics));
}
}
} }
let updated = !old_summary.is_empty() || !new_summary.is_empty(); if !old_summary.is_empty() || !new_summary.is_empty() {
if updated {
if let Some(share) = self.share.as_ref() { if let Some(share) = self.share.as_ref() {
self.client self.client
.send(proto::UpdateDiagnosticSummary { .send(proto::UpdateDiagnosticSummary {
@ -546,7 +580,7 @@ impl LocalWorktree {
worktree_id: self.id().to_proto(), worktree_id: self.id().to_proto(),
summary: Some(proto::DiagnosticSummary { summary: Some(proto::DiagnosticSummary {
path: worktree_path.to_string_lossy().to_string(), path: worktree_path.to_string_lossy().to_string(),
language_server_id: language_server_id as u64, language_server_id: server_id.0 as u64,
error_count: new_summary.error_count as u32, error_count: new_summary.error_count as u32,
warning_count: new_summary.warning_count as u32, warning_count: new_summary.warning_count as u32,
}), }),
@ -555,7 +589,7 @@ impl LocalWorktree {
} }
} }
Ok(updated) Ok(!old_summary.is_empty() || !new_summary.is_empty())
} }
fn set_snapshot(&mut self, new_snapshot: LocalSnapshot, cx: &mut ModelContext<Worktree>) { fn set_snapshot(&mut self, new_snapshot: LocalSnapshot, cx: &mut ModelContext<Worktree>) {
@ -945,13 +979,15 @@ impl LocalWorktree {
let (resume_updates_tx, mut resume_updates_rx) = watch::channel(); let (resume_updates_tx, mut resume_updates_rx) = watch::channel();
let worktree_id = cx.model_id() as u64; let worktree_id = cx.model_id() as u64;
for (path, summary) in self.diagnostic_summaries.iter() { for (path, summaries) in &self.diagnostic_summaries {
if let Err(e) = self.client.send(proto::UpdateDiagnosticSummary { for (&server_id, summary) in summaries {
project_id, if let Err(e) = self.client.send(proto::UpdateDiagnosticSummary {
worktree_id, project_id,
summary: Some(summary.to_proto(&path.0)), worktree_id,
}) { summary: Some(summary.to_proto(server_id, &path)),
return Task::ready(Err(e)); }) {
return Task::ready(Err(e));
}
} }
} }
@ -1109,15 +1145,24 @@ impl RemoteWorktree {
path: Arc<Path>, path: Arc<Path>,
summary: &proto::DiagnosticSummary, summary: &proto::DiagnosticSummary,
) { ) {
let server_id = LanguageServerId(summary.language_server_id as usize);
let summary = DiagnosticSummary { let summary = DiagnosticSummary {
language_server_id: summary.language_server_id as usize,
error_count: summary.error_count as usize, error_count: summary.error_count as usize,
warning_count: summary.warning_count as usize, warning_count: summary.warning_count as usize,
}; };
if summary.is_empty() { if summary.is_empty() {
self.diagnostic_summaries.remove(&PathKey(path)); if let Some(summaries) = self.diagnostic_summaries.get_mut(&path) {
summaries.remove(&server_id);
if summaries.is_empty() {
self.diagnostic_summaries.remove(&path);
}
}
} else { } else {
self.diagnostic_summaries.insert(PathKey(path), summary); self.diagnostic_summaries
.entry(path)
.or_default()
.insert(server_id, summary);
} }
} }

2
crates/rope/Cargo.toml
View File

@ -9,7 +9,7 @@ path = "src/rope.rs"
[dependencies] [dependencies]
bromberg_sl2 = { git = "https://github.com/zed-industries/bromberg_sl2", rev = "950bc5482c216c395049ae33ae4501e08975f17f" } bromberg_sl2 = { git = "https://github.com/zed-industries/bromberg_sl2", rev = "950bc5482c216c395049ae33ae4501e08975f17f" }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
sum_tree = { path = "../sum_tree" } sum_tree = { path = "../sum_tree" }
arrayvec = "0.7.1" arrayvec = "0.7.1"
log = { version = "0.4.16", features = ["kv_unstable_serde"] } log = { version = "0.4.16", features = ["kv_unstable_serde"] }

10
crates/rpc/proto/zed.proto
View File

@ -684,9 +684,10 @@ message SearchProjectResponse {
} }
message CodeAction { message CodeAction {
Anchor start = 1; uint64 server_id = 1;
Anchor end = 2; Anchor start = 2;
bytes lsp_action = 3; Anchor end = 3;
bytes lsp_action = 4;
} }
message ProjectTransaction { message ProjectTransaction {
@ -860,7 +861,8 @@ message IncomingContactRequest {
message UpdateDiagnostics { message UpdateDiagnostics {
uint32 replica_id = 1; uint32 replica_id = 1;
uint32 lamport_timestamp = 2; uint32 lamport_timestamp = 2;
repeated Diagnostic diagnostics = 3; uint64 server_id = 3;
repeated Diagnostic diagnostics = 4;
} }
message Follow { message Follow {

2
crates/rpc/src/rpc.rs
View File

@ -6,4 +6,4 @@ pub use conn::Connection;
pub use peer::*; pub use peer::*;
mod macros; mod macros;
pub const PROTOCOL_VERSION: u32 = 51; pub const PROTOCOL_VERSION: u32 = 52;

2
crates/search/Cargo.toml
View File

@ -25,7 +25,7 @@ log = { version = "0.4.16", features = ["kv_unstable_serde"] }
postage = { workspace = true } postage = { workspace = true }
serde = { workspace = true } serde = { workspace = true }
serde_derive = { workspace = true } serde_derive = { workspace = true }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2" smol = "1.2"
[dev-dependencies] [dev-dependencies]

59
crates/settings/src/settings.rs
View File

@ -252,6 +252,7 @@ pub struct TerminalSettings {
pub working_directory: Option<WorkingDirectory>, pub working_directory: Option<WorkingDirectory>,
pub font_size: Option<f32>, pub font_size: Option<f32>,
pub font_family: Option<String>, pub font_family: Option<String>,
pub line_height: Option<TerminalLineHeight>,
pub font_features: Option<fonts::Features>, pub font_features: Option<fonts::Features>,
pub env: Option<HashMap<String, String>>, pub env: Option<HashMap<String, String>>,
pub blinking: Option<TerminalBlink>, pub blinking: Option<TerminalBlink>,
@ -260,6 +261,25 @@ pub struct TerminalSettings {
pub copy_on_select: Option<bool>, pub copy_on_select: Option<bool>,
} }
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
pub enum TerminalLineHeight {
#[default]
Comfortable,
Standard,
Custom(f32),
}
impl TerminalLineHeight {
fn value(&self) -> f32 {
match self {
TerminalLineHeight::Comfortable => 1.618,
TerminalLineHeight::Standard => 1.3,
TerminalLineHeight::Custom(line_height) => *line_height,
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)] #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "snake_case")] #[serde(rename_all = "snake_case")]
pub enum TerminalBlink { pub enum TerminalBlink {
@ -316,6 +336,14 @@ impl Default for WorkingDirectory {
} }
} }
impl TerminalSettings {
fn line_height(&self) -> Option<f32> {
self.line_height
.to_owned()
.map(|line_height| line_height.value())
}
}
#[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Serialize, Deserialize, JsonSchema)] #[derive(PartialEq, Eq, Debug, Default, Copy, Clone, Hash, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")] #[serde(rename_all = "snake_case")]
pub enum DockAnchor { pub enum DockAnchor {
@ -640,16 +668,6 @@ impl Settings {
}) })
} }
fn terminal_setting<F, R: Default + Clone>(&self, f: F) -> R
where
F: Fn(&TerminalSettings) -> Option<&R>,
{
f(&self.terminal_overrides)
.or_else(|| f(&self.terminal_defaults))
.cloned()
.unwrap_or_else(|| R::default())
}
pub fn telemetry(&self) -> TelemetrySettings { pub fn telemetry(&self) -> TelemetrySettings {
TelemetrySettings { TelemetrySettings {
diagnostics: Some(self.telemetry_diagnostics()), diagnostics: Some(self.telemetry_diagnostics()),
@ -671,20 +689,33 @@ impl Settings {
.expect("missing default") .expect("missing default")
} }
fn terminal_setting<F, R>(&self, f: F) -> R
where
F: Fn(&TerminalSettings) -> Option<R>,
{
None.or_else(|| f(&self.terminal_overrides))
.or_else(|| f(&self.terminal_defaults))
.expect("missing default")
}
pub fn terminal_line_height(&self) -> f32 {
self.terminal_setting(|terminal_setting| terminal_setting.line_height())
}
pub fn terminal_scroll(&self) -> AlternateScroll { pub fn terminal_scroll(&self) -> AlternateScroll {
self.terminal_setting(|terminal_setting| terminal_setting.alternate_scroll.as_ref()) self.terminal_setting(|terminal_setting| terminal_setting.alternate_scroll.to_owned())
} }
pub fn terminal_shell(&self) -> Shell { pub fn terminal_shell(&self) -> Shell {
self.terminal_setting(|terminal_setting| terminal_setting.shell.as_ref()) self.terminal_setting(|terminal_setting| terminal_setting.shell.to_owned())
} }
pub fn terminal_env(&self) -> HashMap<String, String> { pub fn terminal_env(&self) -> HashMap<String, String> {
self.terminal_setting(|terminal_setting| terminal_setting.env.as_ref()) self.terminal_setting(|terminal_setting| terminal_setting.env.to_owned())
} }
pub fn terminal_strategy(&self) -> WorkingDirectory { pub fn terminal_strategy(&self) -> WorkingDirectory {
self.terminal_setting(|terminal_setting| terminal_setting.working_directory.as_ref()) self.terminal_setting(|terminal_setting| terminal_setting.working_directory.to_owned())
} }
#[cfg(any(test, feature = "test-support"))] #[cfg(any(test, feature = "test-support"))]

2
crates/snippet/Cargo.toml
View File

@ -10,4 +10,4 @@ doctest = false
[dependencies] [dependencies]
anyhow = "1.0" anyhow = "1.0"
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }

2
crates/terminal/Cargo.toml
View File

@ -17,7 +17,7 @@ theme = { path = "../theme" }
util = { path = "../util" } util = { path = "../util" }
alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" } alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" }
procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false } procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2.5" smol = "1.2.5"
mio-extras = "2.0.6" mio-extras = "2.0.6"
futures = "0.3" futures = "0.3"

2
crates/terminal_view/Cargo.toml
View File

@ -21,7 +21,7 @@ workspace = { path = "../workspace" }
db = { path = "../db" } db = { path = "../db" }
procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false } procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
terminal = { path = "../terminal" } terminal = { path = "../terminal" }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2.5" smol = "1.2.5"
mio-extras = "2.0.6" mio-extras = "2.0.6"
futures = "0.3" futures = "0.3"

2
crates/terminal_view/src/terminal_element.rs
View File

@ -577,7 +577,7 @@ impl Drawable<TerminalView> for TerminalElement {
let selection_color = settings.theme.editor.selection.selection; let selection_color = settings.theme.editor.selection.selection;
let match_color = settings.theme.search.match_background; let match_color = settings.theme.search.match_background;
let dimensions = { let dimensions = {
let line_height = font_cache.line_height(text_style.font_size); let line_height = text_style.font_size * settings.terminal_line_height();
let cell_width = font_cache.em_advance(text_style.font_id, text_style.font_size); let cell_width = font_cache.em_advance(text_style.font_id, text_style.font_size);
TerminalSize::new(line_height, cell_width, constraint.max) TerminalSize::new(line_height, cell_width, constraint.max)
}; };

2
crates/text/Cargo.toml
View File

@ -24,7 +24,7 @@ log = { version = "0.4.16", features = ["kv_unstable_serde"] }
parking_lot = "0.11" parking_lot = "0.11"
postage = { workspace = true } postage = { workspace = true }
rand = { version = "0.8.3", optional = true } rand = { version = "0.8.3", optional = true }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
util = { path = "../util" } util = { path = "../util" }
regex = "1.5" regex = "1.5"

2
crates/theme_testbench/Cargo.toml
View File

@ -16,4 +16,4 @@ settings = { path = "../settings" }
workspace = { path = "../workspace" } workspace = { path = "../workspace" }
project = { path = "../project" } project = { path = "../project" }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }

2
crates/workspace/Cargo.toml
View File

@ -47,7 +47,7 @@ postage = { workspace = true }
serde = { workspace = true } serde = { workspace = true }
serde_derive = { workspace = true } serde_derive = { workspace = true }
serde_json = { workspace = true } serde_json = { workspace = true }
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
indoc = "1.0.4" indoc = "1.0.4"
uuid = { version = "1.1.2", features = ["v4"] } uuid = { version = "1.1.2", features = ["v4"] }

4
crates/zed/Cargo.toml
View File

@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathansobo@gmail.com>"]
description = "The fast, collaborative code editor." description = "The fast, collaborative code editor."
edition = "2021" edition = "2021"
name = "zed" name = "zed"
version = "0.83.0" version = "0.84.0"
publish = false publish = false
[lib] [lib]
@ -96,7 +96,7 @@ serde_derive = { workspace = true }
serde_json = { workspace = true } serde_json = { workspace = true }
serde_path_to_error = "0.1.4" serde_path_to_error = "0.1.4"
simplelog = "0.9" simplelog = "0.9"
smallvec = { version = "1.6", features = ["union"] } smallvec = { workspace = true }
smol = "1.2.5" smol = "1.2.5"
tempdir = { version = "0.3.7" } tempdir = { version = "0.3.7" }
thiserror = "1.0.29" thiserror = "1.0.29"

84
crates/zed/src/languages.rs
View File

@ -37,121 +37,107 @@ pub fn init(
themes: Arc<ThemeRegistry>, themes: Arc<ThemeRegistry>,
node_runtime: Arc<NodeRuntime>, node_runtime: Arc<NodeRuntime>,
) { ) {
for (name, grammar, lsp_adapter) in [ fn adapter_arc(adapter: impl LspAdapter) -> Arc<dyn LspAdapter> {
Arc::new(adapter)
}
let languages_list = [
( (
"c", "c",
tree_sitter_c::language(), tree_sitter_c::language(),
Some(Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>), vec![adapter_arc(c::CLspAdapter)],
), ),
( (
"cpp", "cpp",
tree_sitter_cpp::language(), tree_sitter_cpp::language(),
Some(Arc::new(c::CLspAdapter)), vec![adapter_arc(c::CLspAdapter)],
),
(
"css",
tree_sitter_css::language(),
None, //
), ),
("css", tree_sitter_css::language(), vec![]),
( (
"elixir", "elixir",
tree_sitter_elixir::language(), tree_sitter_elixir::language(),
Some(Arc::new(elixir::ElixirLspAdapter)), vec![adapter_arc(elixir::ElixirLspAdapter)],
), ),
( (
"go", "go",
tree_sitter_go::language(), tree_sitter_go::language(),
Some(Arc::new(go::GoLspAdapter)), vec![adapter_arc(go::GoLspAdapter)],
), ),
( (
"json", "json",
tree_sitter_json::language(), tree_sitter_json::language(),
Some(Arc::new(json::JsonLspAdapter::new( vec![adapter_arc(json::JsonLspAdapter::new(
node_runtime.clone(), node_runtime.clone(),
languages.clone(), languages.clone(),
themes.clone(), themes.clone(),
))), ))],
),
(
"markdown",
tree_sitter_markdown::language(),
None, //
), ),
("markdown", tree_sitter_markdown::language(), vec![]),
( (
"python", "python",
tree_sitter_python::language(), tree_sitter_python::language(),
Some(Arc::new(python::PythonLspAdapter::new( vec![adapter_arc(python::PythonLspAdapter::new(
node_runtime.clone(), node_runtime.clone(),
))), ))],
), ),
( (
"rust", "rust",
tree_sitter_rust::language(), tree_sitter_rust::language(),
Some(Arc::new(rust::RustLspAdapter)), vec![adapter_arc(rust::RustLspAdapter)],
),
(
"toml",
tree_sitter_toml::language(),
None, //
), ),
("toml", tree_sitter_toml::language(), vec![]),
( (
"tsx", "tsx",
tree_sitter_typescript::language_tsx(), tree_sitter_typescript::language_tsx(),
Some(Arc::new(typescript::TypeScriptLspAdapter::new( vec![adapter_arc(typescript::TypeScriptLspAdapter::new(
node_runtime.clone(), node_runtime.clone(),
))), ))],
), ),
( (
"typescript", "typescript",
tree_sitter_typescript::language_typescript(), tree_sitter_typescript::language_typescript(),
Some(Arc::new(typescript::TypeScriptLspAdapter::new( vec![adapter_arc(typescript::TypeScriptLspAdapter::new(
node_runtime.clone(), node_runtime.clone(),
))), ))],
), ),
( (
"javascript", "javascript",
tree_sitter_typescript::language_tsx(), tree_sitter_typescript::language_tsx(),
Some(Arc::new(typescript::TypeScriptLspAdapter::new( vec![adapter_arc(typescript::TypeScriptLspAdapter::new(
node_runtime.clone(), node_runtime.clone(),
))), ))],
), ),
( (
"html", "html",
tree_sitter_html::language(), tree_sitter_html::language(),
Some(Arc::new(html::HtmlLspAdapter::new(node_runtime.clone()))), vec![adapter_arc(html::HtmlLspAdapter::new(node_runtime.clone()))],
), ),
( (
"ruby", "ruby",
tree_sitter_ruby::language(), tree_sitter_ruby::language(),
Some(Arc::new(ruby::RubyLanguageServer)), vec![adapter_arc(ruby::RubyLanguageServer)],
), ),
( (
"erb", "erb",
tree_sitter_embedded_template::language(), tree_sitter_embedded_template::language(),
Some(Arc::new(ruby::RubyLanguageServer)), vec![adapter_arc(ruby::RubyLanguageServer)],
),
(
"scheme",
tree_sitter_scheme::language(),
None, //
),
(
"racket",
tree_sitter_racket::language(),
None, //
), ),
("scheme", tree_sitter_scheme::language(), vec![]),
("racket", tree_sitter_racket::language(), vec![]),
( (
"lua", "lua",
tree_sitter_lua::language(), tree_sitter_lua::language(),
Some(Arc::new(lua::LuaLspAdapter)), vec![adapter_arc(lua::LuaLspAdapter)],
), ),
( (
"yaml", "yaml",
tree_sitter_yaml::language(), tree_sitter_yaml::language(),
Some(Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))), vec![adapter_arc(yaml::YamlLspAdapter::new(node_runtime.clone()))],
), ),
] { ];
languages.register(name, load_config(name), grammar, lsp_adapter, load_queries);
for (name, grammar, lsp_adapters) in languages_list {
languages.register(name, load_config(name), grammar, lsp_adapters, load_queries);
} }
} }
@ -163,7 +149,7 @@ pub async fn language(
) -> Arc<Language> { ) -> Arc<Language> {
Arc::new( Arc::new(
Language::new(load_config(name), Some(grammar)) Language::new(load_config(name), Some(grammar))
.with_lsp_adapter(lsp_adapter) .with_lsp_adapters(lsp_adapter.into_iter().collect())
.await .await
.with_queries(load_queries(name)) .with_queries(load_queries(name))
.unwrap(), .unwrap(),

169
crates/zed/src/languages/typescript.rs
View File

@ -1,21 +1,23 @@
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use async_trait::async_trait; use async_trait::async_trait;
use futures::StreamExt; use futures::{future::BoxFuture, FutureExt};
use gpui::AppContext;
use language::{LanguageServerBinary, LanguageServerName, LspAdapter}; use language::{LanguageServerBinary, LanguageServerName, LspAdapter};
use lsp::CodeActionKind; use lsp::CodeActionKind;
use node_runtime::NodeRuntime; use node_runtime::NodeRuntime;
use serde_json::json; use serde_json::{json, Value};
use smol::fs; use smol::fs;
use std::{ use std::{
any::Any, any::Any,
ffi::OsString, ffi::OsString,
future,
path::{Path, PathBuf}, path::{Path, PathBuf},
sync::Arc, sync::Arc,
}; };
use util::http::HttpClient; use util::http::HttpClient;
use util::ResultExt; use util::ResultExt;
fn server_binary_arguments(server_path: &Path) -> Vec<OsString> { fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
vec![ vec![
server_path.into(), server_path.into(),
"--stdio".into(), "--stdio".into(),
@ -24,6 +26,10 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
] ]
} }
fn eslint_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
vec![server_path.into(), "--stdio".into()]
}
pub struct TypeScriptLspAdapter { pub struct TypeScriptLspAdapter {
node: Arc<NodeRuntime>, node: Arc<NodeRuntime>,
} }
@ -37,7 +43,7 @@ impl TypeScriptLspAdapter {
} }
} }
struct Versions { struct TypeScriptVersions {
typescript_version: String, typescript_version: String,
server_version: String, server_version: String,
} }
@ -52,7 +58,7 @@ impl LspAdapter for TypeScriptLspAdapter {
&self, &self,
_: Arc<dyn HttpClient>, _: Arc<dyn HttpClient>,
) -> Result<Box<dyn 'static + Send + Any>> { ) -> Result<Box<dyn 'static + Send + Any>> {
Ok(Box::new(Versions { Ok(Box::new(TypeScriptVersions {
typescript_version: self.node.npm_package_latest_version("typescript").await?, typescript_version: self.node.npm_package_latest_version("typescript").await?,
server_version: self server_version: self
.node .node
@ -67,7 +73,7 @@ impl LspAdapter for TypeScriptLspAdapter {
_: Arc<dyn HttpClient>, _: Arc<dyn HttpClient>,
container_dir: PathBuf, container_dir: PathBuf,
) -> Result<LanguageServerBinary> { ) -> Result<LanguageServerBinary> {
let versions = versions.downcast::<Versions>().unwrap(); let versions = versions.downcast::<TypeScriptVersions>().unwrap();
let server_path = container_dir.join(Self::NEW_SERVER_PATH); let server_path = container_dir.join(Self::NEW_SERVER_PATH);
if fs::metadata(&server_path).await.is_err() { if fs::metadata(&server_path).await.is_err() {
@ -87,37 +93,28 @@ impl LspAdapter for TypeScriptLspAdapter {
Ok(LanguageServerBinary { Ok(LanguageServerBinary {
path: self.node.binary_path().await?, path: self.node.binary_path().await?,
arguments: server_binary_arguments(&server_path), arguments: typescript_server_binary_arguments(&server_path),
}) })
} }
async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<LanguageServerBinary> { async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<LanguageServerBinary> {
(|| async move { (|| async move {
let mut last_version_dir = None; let old_server_path = container_dir.join(Self::OLD_SERVER_PATH);
let mut entries = fs::read_dir(&container_dir).await?; let new_server_path = container_dir.join(Self::NEW_SERVER_PATH);
while let Some(entry) = entries.next().await {
let entry = entry?;
if entry.file_type().await?.is_dir() {
last_version_dir = Some(entry.path());
}
}
let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
let old_server_path = last_version_dir.join(Self::OLD_SERVER_PATH);
let new_server_path = last_version_dir.join(Self::NEW_SERVER_PATH);
if new_server_path.exists() { if new_server_path.exists() {
Ok(LanguageServerBinary { Ok(LanguageServerBinary {
path: self.node.binary_path().await?, path: self.node.binary_path().await?,
arguments: server_binary_arguments(&new_server_path), arguments: typescript_server_binary_arguments(&new_server_path),
}) })
} else if old_server_path.exists() { } else if old_server_path.exists() {
Ok(LanguageServerBinary { Ok(LanguageServerBinary {
path: self.node.binary_path().await?, path: self.node.binary_path().await?,
arguments: server_binary_arguments(&old_server_path), arguments: typescript_server_binary_arguments(&old_server_path),
}) })
} else { } else {
Err(anyhow!( Err(anyhow!(
"missing executable in directory {:?}", "missing executable in directory {:?}",
last_version_dir container_dir
)) ))
} }
})() })()
@ -170,6 +167,136 @@ impl LspAdapter for TypeScriptLspAdapter {
} }
} }
pub struct EsLintLspAdapter {
node: Arc<NodeRuntime>,
}
impl EsLintLspAdapter {
const SERVER_PATH: &'static str =
"node_modules/vscode-langservers-extracted/lib/eslint-language-server/eslintServer.js";
#[allow(unused)]
pub fn new(node: Arc<NodeRuntime>) -> Self {
EsLintLspAdapter { node }
}
}
#[async_trait]
impl LspAdapter for EsLintLspAdapter {
fn workspace_configuration(&self, _: &mut AppContext) -> Option<BoxFuture<'static, Value>> {
Some(
future::ready(json!({
"": {
"validate": "on",
"packageManager": "npm",
"useESLintClass": false,
"experimental": {
"useFlatConfig": false
},
"codeActionOnSave": {
"mode": "all"
},
"format": false,
"quiet": false,
"onIgnoredFiles": "off",
"options": {},
"rulesCustomizations": [],
"run": "onType",
"problems": {
"shortenToSingleLine": false
},
"nodePath": null,
"workspaceFolder": {
"name": "testing_ts",
"uri": "file:///Users/julia/Stuff/testing_ts"
},
"codeAction": {
"disableRuleComment": {
"enable": true,
"location": "separateLine",
"commentStyle": "line"
},
"showDocumentation": {
"enable": true
}
}
}
}))
.boxed(),
)
}
async fn name(&self) -> LanguageServerName {
LanguageServerName("eslint".into())
}
async fn fetch_latest_server_version(
&self,
_: Arc<dyn HttpClient>,
) -> Result<Box<dyn 'static + Send + Any>> {
Ok(Box::new(
self.node
.npm_package_latest_version("vscode-langservers-extracted")
.await?,
))
}
async fn fetch_server_binary(
&self,
versions: Box<dyn 'static + Send + Any>,
_: Arc<dyn HttpClient>,
container_dir: PathBuf,
) -> Result<LanguageServerBinary> {
let version = versions.downcast::<String>().unwrap();
let server_path = container_dir.join(Self::SERVER_PATH);
if fs::metadata(&server_path).await.is_err() {
self.node
.npm_install_packages(
[("vscode-langservers-extracted", version.as_str())],
&container_dir,
)
.await?;
}
Ok(LanguageServerBinary {
path: self.node.binary_path().await?,
arguments: eslint_server_binary_arguments(&server_path),
})
}
async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<LanguageServerBinary> {
(|| async move {
let server_path = container_dir.join(Self::SERVER_PATH);
if server_path.exists() {
Ok(LanguageServerBinary {
path: self.node.binary_path().await?,
arguments: eslint_server_binary_arguments(&server_path),
})
} else {
Err(anyhow!(
"missing executable in directory {:?}",
container_dir
))
}
})()
.await
.log_err()
}
async fn label_for_completion(
&self,
_item: &lsp::CompletionItem,
_language: &Arc<language::Language>,
) -> Option<language::CodeLabel> {
None
}
async fn initialization_options(&self) -> Option<serde_json::Value> {
None
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use gpui::TestAppContext; use gpui::TestAppContext;

99
crates/zed/src/main.rs
View File

@ -21,7 +21,7 @@ use log::LevelFilter;
use node_runtime::NodeRuntime; use node_runtime::NodeRuntime;
use parking_lot::Mutex; use parking_lot::Mutex;
use project::Fs; use project::Fs;
use serde_json::json; use serde::{Deserialize, Serialize};
use settings::{ use settings::{
self, settings_file::SettingsFile, KeymapFileContent, Settings, SettingsFileContent, self, settings_file::SettingsFile, KeymapFileContent, Settings, SettingsFileContent,
WorkingDirectory, WorkingDirectory,
@ -317,6 +317,30 @@ fn init_logger() {
} }
} }
#[derive(Serialize, Deserialize)]
struct LocationData {
file: String,
line: u32,
}
#[derive(Serialize, Deserialize)]
struct Panic {
thread: String,
payload: String,
#[serde(skip_serializing_if = "Option::is_none")]
location_data: Option<LocationData>,
backtrace: Vec<String>,
// TODO
// stripped_backtrace: String,
}
#[derive(Serialize)]
struct PanicRequest {
panic: Panic,
version: String,
token: String,
}
fn init_panic_hook(app_version: String) { fn init_panic_hook(app_version: String) {
let is_pty = stdout_is_a_pty(); let is_pty = stdout_is_a_pty();
panic::set_hook(Box::new(move |info| { panic::set_hook(Box::new(move |info| {
@ -333,39 +357,38 @@ fn init_panic_hook(app_version: String) {
}, },
}; };
let message = match info.location() { let panic_data = Panic {
Some(location) => { thread: thread.into(),
format!( payload: payload.into(),
"thread '{}' panicked at '{}'\n{}:{}\n{:?}", location_data: info.location().map(|location| LocationData {
thread, file: location.file().into(),
payload, line: location.line(),
location.file(), }),
location.line(), backtrace: format!("{:?}", backtrace)
backtrace .split("\n")
) .map(|line| line.to_string())
} .collect(),
None => format!( // modified_backtrace: None,
"thread '{}' panicked at '{}'\n{:?}",
thread, payload, backtrace
),
}; };
if is_pty { if let Some(panic_data_json) = serde_json::to_string_pretty(&panic_data).log_err() {
eprintln!("{}", message); if is_pty {
return; eprintln!("{}", panic_data_json);
} return;
}
let timestamp = chrono::Utc::now().format("%Y_%m_%d %H_%M_%S").to_string(); let timestamp = chrono::Utc::now().format("%Y_%m_%d %H_%M_%S").to_string();
let panic_file_path = let panic_file_path =
paths::LOGS_DIR.join(format!("zed-{}-{}.panic", app_version, timestamp)); paths::LOGS_DIR.join(format!("zed-{}-{}.panic", app_version, timestamp));
let panic_file = std::fs::OpenOptions::new() let panic_file = std::fs::OpenOptions::new()
.append(true) .append(true)
.create(true) .create(true)
.open(&panic_file_path) .open(&panic_file_path)
.log_err(); .log_err();
if let Some(mut panic_file) = panic_file { if let Some(mut panic_file) = panic_file {
write!(&mut panic_file, "{}", message).log_err(); write!(&mut panic_file, "{}", panic_data_json).log_err();
panic_file.flush().log_err(); panic_file.flush().log_err();
}
} }
})); }));
} }
@ -402,15 +425,17 @@ fn upload_previous_panics(http: Arc<dyn HttpClient>, cx: &mut AppContext) {
}; };
if diagnostics_telemetry { if diagnostics_telemetry {
let text = smol::fs::read_to_string(&child_path) let panic_data_text = smol::fs::read_to_string(&child_path)
.await .await
.context("error reading panic file")?; .context("error reading panic file")?;
let body = serde_json::to_string(&json!({
"text": text, let body = serde_json::to_string(&PanicRequest {
"version": version, panic: serde_json::from_str(&panic_data_text)?,
"token": ZED_SECRET_CLIENT_TOKEN, version: version.to_string(),
})) token: ZED_SECRET_CLIENT_TOKEN.into(),
})
.unwrap(); .unwrap();
let request = Request::post(&panic_report_url) let request = Request::post(&panic_report_url)
.redirect_policy(isahc::config::RedirectPolicy::Follow) .redirect_policy(isahc::config::RedirectPolicy::Follow)
.header("Content-Type", "application/json") .header("Content-Type", "application/json")