Detailed changes
@@ -4990,6 +4990,30 @@ dependencies = [
"workspace",
]
+[[package]]
+name = "language_tools2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client2",
+ "collections",
+ "editor2",
+ "env_logger 0.9.3",
+ "futures 0.3.28",
+ "gpui2",
+ "language2",
+ "lsp2",
+ "project2",
+ "serde",
+ "settings2",
+ "theme2",
+ "tree-sitter",
+ "ui2",
+ "unindent",
+ "util",
+ "workspace2",
+]
+
[[package]]
name = "lazy_static"
version = "1.4.0"
@@ -12174,6 +12198,7 @@ dependencies = [
"journal2",
"language2",
"language_selector2",
+ "language_tools2",
"lazy_static",
"libc",
"log",
@@ -64,6 +64,7 @@ members = [
"crates/language_selector",
"crates/language_selector2",
"crates/language_tools",
+ "crates/language_tools2",
"crates/live_kit_client",
"crates/live_kit_server",
"crates/lsp",
@@ -68,7 +68,6 @@ impl Render for CollabTitlebarItem {
h_stack()
.id("titlebar")
- .z_index(160) // todo!("z-index")
.justify_between()
.w_full()
.h(rems(1.75))
@@ -1652,14 +1652,11 @@ impl Editor {
Self::new(EditorMode::SingleLine, buffer, None, cx)
}
- // pub fn multi_line(
- // field_editor_style: Option<Arc<GetFieldEditorTheme>>,
- // cx: &mut ViewContext<Self>,
- // ) -> Self {
- // let buffer = cx.build_model(|cx| Buffer::new(0, cx.model_id() as u64, String::new()));
- // let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
- // Self::new(EditorMode::Full, buffer, None, field_editor_style, cx)
- // }
+ pub fn multi_line(cx: &mut ViewContext<Self>) -> Self {
+ let buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), String::new()));
+ let buffer = cx.build_model(|cx| MultiBuffer::singleton(buffer, cx));
+ Self::new(EditorMode::Full, buffer, None, cx)
+ }
pub fn auto_height(max_lines: usize, cx: &mut ViewContext<Self>) -> Self {
let buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), String::new()));
@@ -1427,7 +1427,6 @@ impl Interactivity {
let line_height = cx.line_height();
let scroll_max = (content_size - bounds.size).max(&Size::default());
let interactive_bounds = interactive_bounds.clone();
-
cx.on_mouse_event(move |event: &ScrollWheelEvent, phase, cx| {
if phase == DispatchPhase::Bubble
&& interactive_bounds.visibly_contains(&event.position, cx)
@@ -1492,6 +1491,7 @@ impl Interactivity {
}) {
cx.add_opaque_layer(bounds)
}
+
f(style, scroll_offset.unwrap_or_default(), cx)
})
},
@@ -91,6 +91,14 @@ impl UniformListScrollHandle {
}
}
}
+
+ pub fn scroll_top(&self) -> Pixels {
+ if let Some(state) = &*self.0.borrow() {
+ -state.scroll_offset.borrow().y
+ } else {
+ Pixels::ZERO
+ }
+ }
}
impl Styled for UniformList {
@@ -135,6 +143,7 @@ impl Element for UniformList {
item_size.width
}
});
+
let height = match available_space.height {
AvailableSpace::Definite(height) => desired_height.min(height),
AvailableSpace::MinContent | AvailableSpace::MaxContent => {
@@ -2057,9 +2057,14 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
size: self.window().viewport_size,
},
};
+ let new_stacking_order_id =
+ post_inc(&mut self.window_mut().next_frame.next_stacking_order_id);
+ let old_stacking_order = mem::take(&mut self.window_mut().next_frame.z_index_stack);
+ self.window_mut().next_frame.z_index_stack.id = new_stacking_order_id;
self.window_mut().next_frame.content_mask_stack.push(mask);
let result = f(self);
self.window_mut().next_frame.content_mask_stack.pop();
+ self.window_mut().next_frame.z_index_stack = old_stacking_order;
result
}
@@ -2068,9 +2073,14 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
fn with_z_index<R>(&mut self, z_index: u8, f: impl FnOnce(&mut Self) -> R) -> R {
let new_stacking_order_id =
post_inc(&mut self.window_mut().next_frame.next_stacking_order_id);
+ let old_stacking_order_id = mem::replace(
+ &mut self.window_mut().next_frame.z_index_stack.id,
+ new_stacking_order_id,
+ );
self.window_mut().next_frame.z_index_stack.id = new_stacking_order_id;
self.window_mut().next_frame.z_index_stack.push(z_index);
let result = f(self);
+ self.window_mut().next_frame.z_index_stack.id = old_stacking_order_id;
self.window_mut().next_frame.z_index_stack.pop();
result
}
@@ -0,0 +1,34 @@
+[package]
+name = "language_tools2"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/language_tools.rs"
+doctest = false
+
+[dependencies]
+collections = { path = "../collections" }
+editor = { package = "editor2", path = "../editor2" }
+settings = { package = "settings2", path = "../settings2" }
+theme = { package = "theme2", path = "../theme2" }
+language = { package = "language2", path = "../language2" }
+project = { package = "project2", path = "../project2" }
+workspace = { package = "workspace2", path = "../workspace2" }
+gpui = { package = "gpui2", path = "../gpui2" }
+ui = { package = "ui2", path = "../ui2" }
+util = { path = "../util" }
+lsp = { package = "lsp2", path = "../lsp2" }
+futures.workspace = true
+serde.workspace = true
+anyhow.workspace = true
+tree-sitter.workspace = true
+
+[dev-dependencies]
+client = { package = "client2", path = "../client2", features = ["test-support"] }
+editor = { package = "editor2", path = "../editor2", features = ["test-support"] }
+gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
+util = { path = "../util", features = ["test-support"] }
+env_logger.workspace = true
+unindent.workspace = true
@@ -0,0 +1,15 @@
+mod lsp_log;
+mod syntax_tree_view;
+
+#[cfg(test)]
+mod lsp_log_tests;
+
+use gpui::AppContext;
+
+pub use lsp_log::{LogStore, LspLogToolbarItemView, LspLogView};
+pub use syntax_tree_view::{SyntaxTreeToolbarItemView, SyntaxTreeView};
+
+pub fn init(cx: &mut AppContext) {
+ lsp_log::init(cx);
+ syntax_tree_view::init(cx);
+}
@@ -0,0 +1,896 @@
+use collections::{HashMap, VecDeque};
+use editor::{Editor, EditorElement, EditorEvent, MoveToEnd};
+use futures::{channel::mpsc, StreamExt};
+use gpui::{
+ actions, div, AnchorCorner, AnyElement, AppContext, Context, Div, EventEmitter, FocusHandle,
+ FocusableView, IntoElement, Model, ModelContext, ParentElement, Render, Styled, Subscription,
+ View, ViewContext, VisualContext, WeakModel, WindowContext,
+};
+use language::{LanguageServerId, LanguageServerName};
+use lsp::IoKind;
+use project::{search::SearchQuery, Project};
+use std::{borrow::Cow, sync::Arc};
+use ui::{h_stack, popover_menu, Button, Checkbox, Clickable, ContextMenu, Label, Selection};
+use workspace::{
+ item::{Item, ItemHandle},
+ searchable::{SearchEvent, SearchableItem, SearchableItemHandle},
+ ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
+};
+
+const SEND_LINE: &str = "// Send:";
+const RECEIVE_LINE: &str = "// Receive:";
+const MAX_STORED_LOG_ENTRIES: usize = 2000;
+
+pub struct LogStore {
+ projects: HashMap<WeakModel<Project>, ProjectState>,
+ io_tx: mpsc::UnboundedSender<(WeakModel<Project>, LanguageServerId, IoKind, String)>,
+}
+
+struct ProjectState {
+ servers: HashMap<LanguageServerId, LanguageServerState>,
+ _subscriptions: [gpui::Subscription; 2],
+}
+
+struct LanguageServerState {
+ log_messages: VecDeque<String>,
+ rpc_state: Option<LanguageServerRpcState>,
+ _io_logs_subscription: Option<lsp::Subscription>,
+ _lsp_logs_subscription: Option<lsp::Subscription>,
+}
+
+struct LanguageServerRpcState {
+ rpc_messages: VecDeque<String>,
+ last_message_kind: Option<MessageKind>,
+}
+
+pub struct LspLogView {
+ pub(crate) editor: View<Editor>,
+ editor_subscription: Subscription,
+ log_store: Model<LogStore>,
+ current_server_id: Option<LanguageServerId>,
+ is_showing_rpc_trace: bool,
+ project: Model<Project>,
+ focus_handle: FocusHandle,
+ _log_store_subscriptions: Vec<Subscription>,
+}
+
+pub struct LspLogToolbarItemView {
+ log_view: Option<View<LspLogView>>,
+ _log_view_subscription: Option<Subscription>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+enum MessageKind {
+ Send,
+ Receive,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct LogMenuItem {
+ pub server_id: LanguageServerId,
+ pub server_name: LanguageServerName,
+ pub worktree_root_name: String,
+ pub rpc_trace_enabled: bool,
+ pub rpc_trace_selected: bool,
+ pub logs_selected: bool,
+}
+
+actions!(debug, [OpenLanguageServerLogs]);
+
+pub fn init(cx: &mut AppContext) {
+ let log_store = cx.build_model(|cx| LogStore::new(cx));
+
+ cx.observe_new_views(move |workspace: &mut Workspace, cx| {
+ let project = workspace.project();
+ if project.read(cx).is_local() {
+ log_store.update(cx, |store, cx| {
+ store.add_project(&project, cx);
+ });
+ }
+
+ let log_store = log_store.clone();
+ workspace.register_action(move |workspace, _: &OpenLanguageServerLogs, cx| {
+ let project = workspace.project().read(cx);
+ if project.is_local() {
+ workspace.add_item(
+ Box::new(cx.build_view(|cx| {
+ LspLogView::new(workspace.project().clone(), log_store.clone(), cx)
+ })),
+ cx,
+ );
+ }
+ });
+ })
+ .detach();
+}
+
+impl LogStore {
+ pub fn new(cx: &mut ModelContext<Self>) -> Self {
+ let (io_tx, mut io_rx) = mpsc::unbounded();
+ let this = Self {
+ projects: HashMap::default(),
+ io_tx,
+ };
+ cx.spawn(|this, mut cx| async move {
+ while let Some((project, server_id, io_kind, message)) = io_rx.next().await {
+ if let Some(this) = this.upgrade() {
+ this.update(&mut cx, |this, cx| {
+ this.on_io(project, server_id, io_kind, &message, cx);
+ })?;
+ }
+ }
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ this
+ }
+
+ pub fn add_project(&mut self, project: &Model<Project>, cx: &mut ModelContext<Self>) {
+ let weak_project = project.downgrade();
+ self.projects.insert(
+ project.downgrade(),
+ ProjectState {
+ servers: HashMap::default(),
+ _subscriptions: [
+ cx.observe_release(project, move |this, _, _| {
+ this.projects.remove(&weak_project);
+ }),
+ cx.subscribe(project, |this, project, event, cx| match event {
+ project::Event::LanguageServerAdded(id) => {
+ this.add_language_server(&project, *id, cx);
+ }
+ project::Event::LanguageServerRemoved(id) => {
+ this.remove_language_server(&project, *id, cx);
+ }
+ project::Event::LanguageServerLog(id, message) => {
+ this.add_language_server_log(&project, *id, message, cx);
+ }
+ _ => {}
+ }),
+ ],
+ },
+ );
+ }
+
+ fn add_language_server(
+ &mut self,
+ project: &Model<Project>,
+ id: LanguageServerId,
+ cx: &mut ModelContext<Self>,
+ ) -> Option<&mut LanguageServerState> {
+ let project_state = self.projects.get_mut(&project.downgrade())?;
+ let server_state = project_state.servers.entry(id).or_insert_with(|| {
+ cx.notify();
+ LanguageServerState {
+ rpc_state: None,
+ log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
+ _io_logs_subscription: None,
+ _lsp_logs_subscription: None,
+ }
+ });
+
+ let server = project.read(cx).language_server_for_id(id);
+ if let Some(server) = server.as_deref() {
+ if server.has_notification_handler::<lsp::notification::LogMessage>() {
+ // Another event wants to re-add the server that was already added and subscribed to, avoid doing it again.
+ return Some(server_state);
+ }
+ }
+
+ let weak_project = project.downgrade();
+ let io_tx = self.io_tx.clone();
+ server_state._io_logs_subscription = server.as_ref().map(|server| {
+ server.on_io(move |io_kind, message| {
+ io_tx
+ .unbounded_send((weak_project.clone(), id, io_kind, message.to_string()))
+ .ok();
+ })
+ });
+ let this = cx.handle().downgrade();
+ let weak_project = project.downgrade();
+ server_state._lsp_logs_subscription = server.map(|server| {
+ let server_id = server.server_id();
+ server.on_notification::<lsp::notification::LogMessage, _>({
+ move |params, mut cx| {
+ if let Some((project, this)) = weak_project.upgrade().zip(this.upgrade()) {
+ this.update(&mut cx, |this, cx| {
+ this.add_language_server_log(&project, server_id, ¶ms.message, cx);
+ })
+ .ok();
+ }
+ }
+ })
+ });
+ Some(server_state)
+ }
+
+ fn add_language_server_log(
+ &mut self,
+ project: &Model<Project>,
+ id: LanguageServerId,
+ message: &str,
+ cx: &mut ModelContext<Self>,
+ ) -> Option<()> {
+ let language_server_state = match self
+ .projects
+ .get_mut(&project.downgrade())?
+ .servers
+ .get_mut(&id)
+ {
+ Some(existing_state) => existing_state,
+ None => self.add_language_server(&project, id, cx)?,
+ };
+
+ let log_lines = &mut language_server_state.log_messages;
+ while log_lines.len() >= MAX_STORED_LOG_ENTRIES {
+ log_lines.pop_front();
+ }
+ let message = message.trim();
+ log_lines.push_back(message.to_string());
+ cx.emit(Event::NewServerLogEntry {
+ id,
+ entry: message.to_string(),
+ is_rpc: false,
+ });
+ cx.notify();
+ Some(())
+ }
+
+ fn remove_language_server(
+ &mut self,
+ project: &Model<Project>,
+ id: LanguageServerId,
+ cx: &mut ModelContext<Self>,
+ ) -> Option<()> {
+ let project_state = self.projects.get_mut(&project.downgrade())?;
+ project_state.servers.remove(&id);
+ cx.notify();
+ Some(())
+ }
+
+ fn server_logs(
+ &self,
+ project: &Model<Project>,
+ server_id: LanguageServerId,
+ ) -> Option<&VecDeque<String>> {
+ let weak_project = project.downgrade();
+ let project_state = self.projects.get(&weak_project)?;
+ let server_state = project_state.servers.get(&server_id)?;
+ Some(&server_state.log_messages)
+ }
+
+ fn enable_rpc_trace_for_language_server(
+ &mut self,
+ project: &Model<Project>,
+ server_id: LanguageServerId,
+ ) -> Option<&mut LanguageServerRpcState> {
+ let weak_project = project.downgrade();
+ let project_state = self.projects.get_mut(&weak_project)?;
+ let server_state = project_state.servers.get_mut(&server_id)?;
+ let rpc_state = server_state
+ .rpc_state
+ .get_or_insert_with(|| LanguageServerRpcState {
+ rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
+ last_message_kind: None,
+ });
+ Some(rpc_state)
+ }
+
+ pub fn disable_rpc_trace_for_language_server(
+ &mut self,
+ project: &Model<Project>,
+ server_id: LanguageServerId,
+ _: &mut ModelContext<Self>,
+ ) -> Option<()> {
+ let project = project.downgrade();
+ let project_state = self.projects.get_mut(&project)?;
+ let server_state = project_state.servers.get_mut(&server_id)?;
+ server_state.rpc_state.take();
+ Some(())
+ }
+
+ fn on_io(
+ &mut self,
+ project: WeakModel<Project>,
+ language_server_id: LanguageServerId,
+ io_kind: IoKind,
+ message: &str,
+ cx: &mut ModelContext<Self>,
+ ) -> Option<()> {
+ let is_received = match io_kind {
+ IoKind::StdOut => true,
+ IoKind::StdIn => false,
+ IoKind::StdErr => {
+ let project = project.upgrade()?;
+ let message = format!("stderr: {}", message.trim());
+ self.add_language_server_log(&project, language_server_id, &message, cx);
+ return Some(());
+ }
+ };
+
+ let state = self
+ .projects
+ .get_mut(&project)?
+ .servers
+ .get_mut(&language_server_id)?
+ .rpc_state
+ .as_mut()?;
+ let kind = if is_received {
+ MessageKind::Receive
+ } else {
+ MessageKind::Send
+ };
+
+ let rpc_log_lines = &mut state.rpc_messages;
+ if state.last_message_kind != Some(kind) {
+ let line_before_message = match kind {
+ MessageKind::Send => SEND_LINE,
+ MessageKind::Receive => RECEIVE_LINE,
+ };
+ rpc_log_lines.push_back(line_before_message.to_string());
+ cx.emit(Event::NewServerLogEntry {
+ id: language_server_id,
+ entry: line_before_message.to_string(),
+ is_rpc: true,
+ });
+ }
+
+ while rpc_log_lines.len() >= MAX_STORED_LOG_ENTRIES {
+ rpc_log_lines.pop_front();
+ }
+ let message = message.trim();
+ rpc_log_lines.push_back(message.to_string());
+ cx.emit(Event::NewServerLogEntry {
+ id: language_server_id,
+ entry: message.to_string(),
+ is_rpc: true,
+ });
+ cx.notify();
+ Some(())
+ }
+}
+
+impl LspLogView {
+ pub fn new(
+ project: Model<Project>,
+ log_store: Model<LogStore>,
+ cx: &mut ViewContext<Self>,
+ ) -> Self {
+ let server_id = log_store
+ .read(cx)
+ .projects
+ .get(&project.downgrade())
+ .and_then(|project| project.servers.keys().copied().next());
+ let model_changes_subscription = cx.observe(&log_store, |this, store, cx| {
+ (|| -> Option<()> {
+ let project_state = store.read(cx).projects.get(&this.project.downgrade())?;
+ if let Some(current_lsp) = this.current_server_id {
+ if !project_state.servers.contains_key(¤t_lsp) {
+ if let Some(server) = project_state.servers.iter().next() {
+ if this.is_showing_rpc_trace {
+ this.show_rpc_trace_for_server(*server.0, cx)
+ } else {
+ this.show_logs_for_server(*server.0, cx)
+ }
+ } else {
+ this.current_server_id = None;
+ this.editor.update(cx, |editor, cx| {
+ editor.set_read_only(false);
+ editor.clear(cx);
+ editor.set_read_only(true);
+ });
+ cx.notify();
+ }
+ }
+ } else {
+ if let Some(server) = project_state.servers.iter().next() {
+ if this.is_showing_rpc_trace {
+ this.show_rpc_trace_for_server(*server.0, cx)
+ } else {
+ this.show_logs_for_server(*server.0, cx)
+ }
+ }
+ }
+
+ Some(())
+ })();
+
+ cx.notify();
+ });
+ let events_subscriptions = cx.subscribe(&log_store, |log_view, _, e, cx| match e {
+ Event::NewServerLogEntry { id, entry, is_rpc } => {
+ if log_view.current_server_id == Some(*id) {
+ if (*is_rpc && log_view.is_showing_rpc_trace)
+ || (!*is_rpc && !log_view.is_showing_rpc_trace)
+ {
+ log_view.editor.update(cx, |editor, cx| {
+ editor.set_read_only(false);
+ editor.handle_input(entry.trim(), cx);
+ editor.handle_input("\n", cx);
+ editor.set_read_only(true);
+ });
+ }
+ }
+ }
+ });
+ let (editor, editor_subscription) = Self::editor_for_logs(String::new(), cx);
+
+ let focus_handle = cx.focus_handle();
+ let focus_subscription = cx.on_focus(&focus_handle, |log_view, cx| {
+ cx.focus_view(&log_view.editor);
+ });
+
+ let mut this = Self {
+ focus_handle,
+ editor,
+ editor_subscription,
+ project,
+ log_store,
+ current_server_id: None,
+ is_showing_rpc_trace: false,
+ _log_store_subscriptions: vec![
+ model_changes_subscription,
+ events_subscriptions,
+ focus_subscription,
+ ],
+ };
+ if let Some(server_id) = server_id {
+ this.show_logs_for_server(server_id, cx);
+ }
+ this
+ }
+
+ fn editor_for_logs(
+ log_contents: String,
+ cx: &mut ViewContext<Self>,
+ ) -> (View<Editor>, Subscription) {
+ let editor = cx.build_view(|cx| {
+ let mut editor = Editor::multi_line(cx);
+ editor.set_text(log_contents, cx);
+ editor.move_to_end(&MoveToEnd, cx);
+ editor.set_read_only(true);
+ editor
+ });
+ let editor_subscription = cx.subscribe(
+ &editor,
+ |_, _, event: &EditorEvent, cx: &mut ViewContext<'_, LspLogView>| {
+ cx.emit(event.clone())
+ },
+ );
+ (editor, editor_subscription)
+ }
+
+ pub(crate) fn menu_items<'a>(&'a self, cx: &'a AppContext) -> Option<Vec<LogMenuItem>> {
+ let log_store = self.log_store.read(cx);
+ let state = log_store.projects.get(&self.project.downgrade())?;
+ let mut rows = self
+ .project
+ .read(cx)
+ .language_servers()
+ .filter_map(|(server_id, language_server_name, worktree_id)| {
+ let worktree = self.project.read(cx).worktree_for_id(worktree_id, cx)?;
+ let state = state.servers.get(&server_id)?;
+ Some(LogMenuItem {
+ server_id,
+ server_name: language_server_name,
+ worktree_root_name: worktree.read(cx).root_name().to_string(),
+ rpc_trace_enabled: state.rpc_state.is_some(),
+ rpc_trace_selected: self.is_showing_rpc_trace
+ && self.current_server_id == Some(server_id),
+ logs_selected: !self.is_showing_rpc_trace
+ && self.current_server_id == Some(server_id),
+ })
+ })
+ .chain(
+ self.project
+ .read(cx)
+ .supplementary_language_servers()
+ .filter_map(|(&server_id, (name, _))| {
+ let state = state.servers.get(&server_id)?;
+ Some(LogMenuItem {
+ server_id,
+ server_name: name.clone(),
+ worktree_root_name: "supplementary".to_string(),
+ rpc_trace_enabled: state.rpc_state.is_some(),
+ rpc_trace_selected: self.is_showing_rpc_trace
+ && self.current_server_id == Some(server_id),
+ logs_selected: !self.is_showing_rpc_trace
+ && self.current_server_id == Some(server_id),
+ })
+ }),
+ )
+ .collect::<Vec<_>>();
+ rows.sort_by_key(|row| row.server_id);
+ rows.dedup_by_key(|row| row.server_id);
+ Some(rows)
+ }
+
+ fn show_logs_for_server(&mut self, server_id: LanguageServerId, cx: &mut ViewContext<Self>) {
+ let log_contents = self
+ .log_store
+ .read(cx)
+ .server_logs(&self.project, server_id)
+ .map(log_contents);
+ if let Some(log_contents) = log_contents {
+ self.current_server_id = Some(server_id);
+ self.is_showing_rpc_trace = false;
+ let (editor, editor_subscription) = Self::editor_for_logs(log_contents, cx);
+ self.editor = editor;
+ self.editor_subscription = editor_subscription;
+ cx.notify();
+ }
+ cx.focus(&self.focus_handle);
+ }
+
+ fn show_rpc_trace_for_server(
+ &mut self,
+ server_id: LanguageServerId,
+ cx: &mut ViewContext<Self>,
+ ) {
+ let rpc_log = self.log_store.update(cx, |log_store, _| {
+ log_store
+ .enable_rpc_trace_for_language_server(&self.project, server_id)
+ .map(|state| log_contents(&state.rpc_messages))
+ });
+ if let Some(rpc_log) = rpc_log {
+ self.current_server_id = Some(server_id);
+ self.is_showing_rpc_trace = true;
+ let (editor, editor_subscription) = Self::editor_for_logs(rpc_log, cx);
+ let language = self.project.read(cx).languages().language_for_name("JSON");
+ editor
+ .read(cx)
+ .buffer()
+ .read(cx)
+ .as_singleton()
+ .expect("log buffer should be a singleton")
+ .update(cx, |_, cx| {
+ cx.spawn({
+ let buffer = cx.handle();
+ |_, mut cx| async move {
+ let language = language.await.ok();
+ buffer.update(&mut cx, |buffer, cx| {
+ buffer.set_language(language, cx);
+ })
+ }
+ })
+ .detach_and_log_err(cx);
+ });
+
+ self.editor = editor;
+ self.editor_subscription = editor_subscription;
+ cx.notify();
+ }
+
+ cx.focus(&self.focus_handle);
+ }
+
+ fn toggle_rpc_trace_for_server(
+ &mut self,
+ server_id: LanguageServerId,
+ enabled: bool,
+ cx: &mut ViewContext<Self>,
+ ) {
+ self.log_store.update(cx, |log_store, cx| {
+ if enabled {
+ log_store.enable_rpc_trace_for_language_server(&self.project, server_id);
+ } else {
+ log_store.disable_rpc_trace_for_language_server(&self.project, server_id, cx);
+ }
+ });
+ if !enabled && Some(server_id) == self.current_server_id {
+ self.show_logs_for_server(server_id, cx);
+ cx.notify();
+ }
+ }
+}
+
+fn log_contents(lines: &VecDeque<String>) -> String {
+ let (a, b) = lines.as_slices();
+ let log_contents = a.join("\n");
+ if b.is_empty() {
+ log_contents
+ } else {
+ log_contents + "\n" + &b.join("\n")
+ }
+}
+
+impl Render for LspLogView {
+ type Element = EditorElement;
+
+ fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+ self.editor.update(cx, |editor, cx| editor.render(cx))
+ }
+}
+
+impl FocusableView for LspLogView {
+ fn focus_handle(&self, _: &AppContext) -> FocusHandle {
+ self.focus_handle.clone()
+ }
+}
+
+impl Item for LspLogView {
+ type Event = EditorEvent;
+
+ fn to_item_events(event: &Self::Event, f: impl FnMut(workspace::item::ItemEvent)) {
+ Editor::to_item_events(event, f)
+ }
+
+ fn tab_content(&self, _: Option<usize>, _: bool, _: &WindowContext<'_>) -> AnyElement {
+ Label::new("LSP Logs").into_any_element()
+ }
+
+ fn as_searchable(&self, handle: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+ Some(Box::new(handle.clone()))
+ }
+}
+
+impl SearchableItem for LspLogView {
+ type Match = <Editor as SearchableItem>::Match;
+
+ fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
+ self.editor.update(cx, |e, cx| e.clear_matches(cx))
+ }
+
+ fn update_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
+ self.editor
+ .update(cx, |e, cx| e.update_matches(matches, cx))
+ }
+
+ fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
+ self.editor.update(cx, |e, cx| e.query_suggestion(cx))
+ }
+
+ fn activate_match(
+ &mut self,
+ index: usize,
+ matches: Vec<Self::Match>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ self.editor
+ .update(cx, |e, cx| e.activate_match(index, matches, cx))
+ }
+
+ fn select_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
+ self.editor
+ .update(cx, |e, cx| e.select_matches(matches, cx))
+ }
+
+ fn find_matches(
+ &mut self,
+ query: Arc<project::search::SearchQuery>,
+ cx: &mut ViewContext<Self>,
+ ) -> gpui::Task<Vec<Self::Match>> {
+ self.editor.update(cx, |e, cx| e.find_matches(query, cx))
+ }
+
+ fn replace(&mut self, _: &Self::Match, _: &SearchQuery, _: &mut ViewContext<Self>) {
+ // Since LSP Log is read-only, it doesn't make sense to support replace operation.
+ }
+ fn supported_options() -> workspace::searchable::SearchOptions {
+ workspace::searchable::SearchOptions {
+ case: true,
+ word: true,
+ regex: true,
+ // LSP log is read-only.
+ replacement: false,
+ }
+ }
+ fn active_match_index(
+ &mut self,
+ matches: Vec<Self::Match>,
+ cx: &mut ViewContext<Self>,
+ ) -> Option<usize> {
+ self.editor
+ .update(cx, |e, cx| e.active_match_index(matches, cx))
+ }
+}
+
+impl EventEmitter<ToolbarItemEvent> for LspLogToolbarItemView {}
+
+impl ToolbarItemView for LspLogToolbarItemView {
+ fn set_active_pane_item(
+ &mut self,
+ active_pane_item: Option<&dyn ItemHandle>,
+ cx: &mut ViewContext<Self>,
+ ) -> workspace::ToolbarItemLocation {
+ if let Some(item) = active_pane_item {
+ if let Some(log_view) = item.downcast::<LspLogView>() {
+ self.log_view = Some(log_view.clone());
+ self._log_view_subscription = Some(cx.observe(&log_view, |_, _, cx| {
+ cx.notify();
+ }));
+ return ToolbarItemLocation::PrimaryLeft;
+ }
+ }
+ self.log_view = None;
+ self._log_view_subscription = None;
+ ToolbarItemLocation::Hidden
+ }
+}
+
+impl Render for LspLogToolbarItemView {
+ type Element = Div;
+
+ fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+ let Some(log_view) = self.log_view.clone() else {
+ return div();
+ };
+ let (menu_rows, current_server_id) = log_view.update(cx, |log_view, cx| {
+ let menu_rows = log_view.menu_items(cx).unwrap_or_default();
+ let current_server_id = log_view.current_server_id;
+ (menu_rows, current_server_id)
+ });
+
+ let current_server = current_server_id.and_then(|current_server_id| {
+ if let Ok(ix) = menu_rows.binary_search_by_key(¤t_server_id, |e| e.server_id) {
+ Some(menu_rows[ix].clone())
+ } else {
+ None
+ }
+ });
+
+ let log_toolbar_view = cx.view().clone();
+ let lsp_menu = popover_menu("LspLogView")
+ .anchor(AnchorCorner::TopLeft)
+ .trigger(Button::new(
+ "language_server_menu_header",
+ current_server
+ .and_then(|row| {
+ Some(Cow::Owned(format!(
+ "{} ({}) - {}",
+ row.server_name.0,
+ row.worktree_root_name,
+ if row.rpc_trace_selected {
+ RPC_MESSAGES
+ } else {
+ SERVER_LOGS
+ },
+ )))
+ })
+ .unwrap_or_else(|| "No server selected".into()),
+ ))
+ .menu(move |cx| {
+ let menu_rows = menu_rows.clone();
+ let log_view = log_view.clone();
+ let log_toolbar_view = log_toolbar_view.clone();
+ ContextMenu::build(cx, move |mut menu, cx| {
+ for (ix, row) in menu_rows.into_iter().enumerate() {
+ let server_selected = Some(row.server_id) == current_server_id;
+ menu = menu
+ .header(format!(
+ "{} ({})",
+ row.server_name.0, row.worktree_root_name
+ ))
+ .entry(
+ SERVER_LOGS,
+ cx.handler_for(&log_view, move |view, cx| {
+ view.show_logs_for_server(row.server_id, cx);
+ }),
+ );
+ if server_selected && row.logs_selected {
+ debug_assert_eq!(
+ Some(ix * 3 + 1),
+ menu.select_last(),
+ "Could not scroll to a just added LSP menu item"
+ );
+ }
+
+ menu = menu.custom_entry(
+ {
+ let log_toolbar_view = log_toolbar_view.clone();
+ move |cx| {
+ h_stack()
+ .w_full()
+ .justify_between()
+ .child(Label::new(RPC_MESSAGES))
+ .child(
+ div().z_index(120).child(
+ Checkbox::new(
+ ix,
+ if row.rpc_trace_enabled {
+ Selection::Selected
+ } else {
+ Selection::Unselected
+ },
+ )
+ .on_click(cx.listener_for(
+ &log_toolbar_view,
+ move |view, selection, cx| {
+ let enabled = matches!(
+ selection,
+ Selection::Selected
+ );
+ view.toggle_logging_for_server(
+ row.server_id,
+ enabled,
+ cx,
+ );
+ cx.stop_propagation();
+ },
+ )),
+ ),
+ )
+ .into_any_element()
+ }
+ },
+ cx.handler_for(&log_view, move |view, cx| {
+ view.show_rpc_trace_for_server(row.server_id, cx);
+ }),
+ );
+ if server_selected && row.rpc_trace_selected {
+ debug_assert_eq!(
+ Some(ix * 3 + 2),
+ menu.select_last(),
+ "Could not scroll to a just added LSP menu item"
+ );
+ }
+ }
+ menu
+ })
+ });
+
+ h_stack().size_full().child(lsp_menu).child(
+ div()
+ .child(
+ Button::new("clear_log_button", "Clear").on_click(cx.listener(
+ |this, _, cx| {
+ if let Some(log_view) = this.log_view.as_ref() {
+ log_view.update(cx, |log_view, cx| {
+ log_view.editor.update(cx, |editor, cx| {
+ editor.set_read_only(false);
+ editor.clear(cx);
+ editor.set_read_only(true);
+ });
+ })
+ }
+ },
+ )),
+ )
+ .ml_2(),
+ )
+ }
+}
+
+const RPC_MESSAGES: &str = "RPC Messages";
+const SERVER_LOGS: &str = "Server Logs";
+
+impl LspLogToolbarItemView {
+ pub fn new() -> Self {
+ Self {
+ log_view: None,
+ _log_view_subscription: None,
+ }
+ }
+
+ fn toggle_logging_for_server(
+ &mut self,
+ id: LanguageServerId,
+ enabled: bool,
+ cx: &mut ViewContext<Self>,
+ ) {
+ if let Some(log_view) = &self.log_view {
+ log_view.update(cx, |log_view, cx| {
+ log_view.toggle_rpc_trace_for_server(id, enabled, cx);
+ if !enabled && Some(id) == log_view.current_server_id {
+ log_view.show_logs_for_server(id, cx);
+ cx.notify();
+ }
+ cx.focus(&log_view.focus_handle);
+ });
+ }
+ cx.notify();
+ }
+}
+
+pub enum Event {
+ NewServerLogEntry {
+ id: LanguageServerId,
+ entry: String,
+ is_rpc: bool,
+ },
+}
+
+impl EventEmitter<Event> for LogStore {}
+impl EventEmitter<Event> for LspLogView {}
+impl EventEmitter<EditorEvent> for LspLogView {}
+impl EventEmitter<SearchEvent> for LspLogView {}
@@ -0,0 +1,107 @@
+use std::sync::Arc;
+
+use crate::lsp_log::LogMenuItem;
+
+use super::*;
+use futures::StreamExt;
+use gpui::{serde_json::json, Context, TestAppContext, VisualTestContext};
+use language::{tree_sitter_rust, FakeLspAdapter, Language, LanguageConfig, LanguageServerName};
+use project::{FakeFs, Project};
+use settings::SettingsStore;
+
+#[gpui::test]
+async fn test_lsp_logs(cx: &mut TestAppContext) {
+ if std::env::var("RUST_LOG").is_ok() {
+ env_logger::init();
+ }
+
+ init_test(cx);
+
+ let mut rust_language = Language::new(
+ LanguageConfig {
+ name: "Rust".into(),
+ path_suffixes: vec!["rs".to_string()],
+ ..Default::default()
+ },
+ Some(tree_sitter_rust::language()),
+ );
+ let mut fake_rust_servers = rust_language
+ .set_fake_lsp_adapter(Arc::new(FakeLspAdapter {
+ name: "the-rust-language-server",
+ ..Default::default()
+ }))
+ .await;
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ "/the-root",
+ json!({
+ "test.rs": "",
+ "package.json": "",
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), ["/the-root".as_ref()], cx).await;
+ project.update(cx, |project, _| {
+ project.languages().add(Arc::new(rust_language));
+ });
+
+ let log_store = cx.build_model(|cx| LogStore::new(cx));
+ log_store.update(cx, |store, cx| store.add_project(&project, cx));
+
+ let _rust_buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/the-root/test.rs", cx)
+ })
+ .await
+ .unwrap();
+
+ let mut language_server = fake_rust_servers.next().await.unwrap();
+ language_server
+ .receive_notification::<lsp::notification::DidOpenTextDocument>()
+ .await;
+
+ let window = cx.add_window(|cx| LspLogView::new(project.clone(), log_store.clone(), cx));
+ let log_view = window.root(cx).unwrap();
+ let mut cx = VisualTestContext::from_window(*window, cx);
+
+ language_server.notify::<lsp::notification::LogMessage>(lsp::LogMessageParams {
+ message: "hello from the server".into(),
+ typ: lsp::MessageType::INFO,
+ });
+ cx.executor().run_until_parked();
+
+ log_view.update(&mut cx, |view, cx| {
+ assert_eq!(
+ view.menu_items(cx).unwrap(),
+ &[LogMenuItem {
+ server_id: language_server.server.server_id(),
+ server_name: LanguageServerName("the-rust-language-server".into()),
+ worktree_root_name: project
+ .read(cx)
+ .worktrees()
+ .next()
+ .unwrap()
+ .read(cx)
+ .root_name()
+ .to_string(),
+ rpc_trace_enabled: false,
+ rpc_trace_selected: false,
+ logs_selected: true,
+ }]
+ );
+ assert_eq!(view.editor.read(cx).text(cx), "hello from the server\n");
+ });
+}
+
+fn init_test(cx: &mut gpui::TestAppContext) {
+ cx.update(|cx| {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ theme::init(theme::LoadThemes::JustBase, cx);
+ language::init(cx);
+ client::init_settings(cx);
+ Project::init_settings(cx);
+ editor::init_settings(cx);
+ });
+}
@@ -0,0 +1,535 @@
+use editor::{scroll::autoscroll::Autoscroll, Anchor, Editor, ExcerptId};
+use gpui::{
+ actions, canvas, div, rems, uniform_list, AnyElement, AppContext, AvailableSpace, Div,
+ EventEmitter, FocusHandle, FocusableView, Hsla, InteractiveElement, IntoElement, Model,
+ MouseButton, MouseDownEvent, MouseMoveEvent, ParentElement, Pixels, Render, Styled,
+ UniformListScrollHandle, View, ViewContext, VisualContext, WeakView, WindowContext,
+};
+use language::{Buffer, OwnedSyntaxLayerInfo};
+use settings::Settings;
+use std::{mem, ops::Range};
+use theme::{ActiveTheme, ThemeSettings};
+use tree_sitter::{Node, TreeCursor};
+use ui::{h_stack, popover_menu, ButtonLike, Color, ContextMenu, Label, LabelCommon, PopoverMenu};
+use workspace::{
+ item::{Item, ItemHandle},
+ SplitDirection, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
+};
+
+actions!(debug, [OpenSyntaxTreeView]);
+
+pub fn init(cx: &mut AppContext) {
+ cx.observe_new_views(|workspace: &mut Workspace, _| {
+ workspace.register_action(|workspace, _: &OpenSyntaxTreeView, cx| {
+ let active_item = workspace.active_item(cx);
+ let workspace_handle = workspace.weak_handle();
+ let syntax_tree_view =
+ cx.build_view(|cx| SyntaxTreeView::new(workspace_handle, active_item, cx));
+ workspace.split_item(SplitDirection::Right, Box::new(syntax_tree_view), cx)
+ });
+ })
+ .detach();
+}
+
+pub struct SyntaxTreeView {
+ workspace_handle: WeakView<Workspace>,
+ editor: Option<EditorState>,
+ mouse_y: Option<Pixels>,
+ line_height: Option<Pixels>,
+ list_scroll_handle: UniformListScrollHandle,
+ selected_descendant_ix: Option<usize>,
+ hovered_descendant_ix: Option<usize>,
+ focus_handle: FocusHandle,
+}
+
+pub struct SyntaxTreeToolbarItemView {
+ tree_view: Option<View<SyntaxTreeView>>,
+ subscription: Option<gpui::Subscription>,
+}
+
+struct EditorState {
+ editor: View<Editor>,
+ active_buffer: Option<BufferState>,
+ _subscription: gpui::Subscription,
+}
+
+#[derive(Clone)]
+struct BufferState {
+ buffer: Model<Buffer>,
+ excerpt_id: ExcerptId,
+ active_layer: Option<OwnedSyntaxLayerInfo>,
+}
+
+impl SyntaxTreeView {
+ pub fn new(
+ workspace_handle: WeakView<Workspace>,
+ active_item: Option<Box<dyn ItemHandle>>,
+ cx: &mut ViewContext<Self>,
+ ) -> Self {
+ let mut this = Self {
+ workspace_handle: workspace_handle.clone(),
+ list_scroll_handle: UniformListScrollHandle::new(),
+ editor: None,
+ mouse_y: None,
+ line_height: None,
+ hovered_descendant_ix: None,
+ selected_descendant_ix: None,
+ focus_handle: cx.focus_handle(),
+ };
+
+ this.workspace_updated(active_item, cx);
+ cx.observe(
+ &workspace_handle.upgrade().unwrap(),
+ |this, workspace, cx| {
+ this.workspace_updated(workspace.read(cx).active_item(cx), cx);
+ },
+ )
+ .detach();
+
+ this
+ }
+
+ fn workspace_updated(
+ &mut self,
+ active_item: Option<Box<dyn ItemHandle>>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ if let Some(item) = active_item {
+ if item.item_id() != cx.entity_id() {
+ if let Some(editor) = item.act_as::<Editor>(cx) {
+ self.set_editor(editor, cx);
+ }
+ }
+ }
+ }
+
+ fn set_editor(&mut self, editor: View<Editor>, cx: &mut ViewContext<Self>) {
+ if let Some(state) = &self.editor {
+ if state.editor == editor {
+ return;
+ }
+ editor.update(cx, |editor, cx| {
+ editor.clear_background_highlights::<Self>(cx)
+ });
+ }
+
+ let subscription = cx.subscribe(&editor, |this, _, event, cx| {
+ let did_reparse = match event {
+ editor::EditorEvent::Reparsed => true,
+ editor::EditorEvent::SelectionsChanged { .. } => false,
+ _ => return,
+ };
+ this.editor_updated(did_reparse, cx);
+ });
+
+ self.editor = Some(EditorState {
+ editor,
+ _subscription: subscription,
+ active_buffer: None,
+ });
+ self.editor_updated(true, cx);
+ }
+
+ fn editor_updated(&mut self, did_reparse: bool, cx: &mut ViewContext<Self>) -> Option<()> {
+ // Find which excerpt the cursor is in, and the position within that excerpted buffer.
+ let editor_state = self.editor.as_mut()?;
+ let editor = &editor_state.editor.read(cx);
+ let selection_range = editor.selections.last::<usize>(cx).range();
+ let multibuffer = editor.buffer().read(cx);
+ let (buffer, range, excerpt_id) = multibuffer
+ .range_to_buffer_ranges(selection_range, cx)
+ .pop()?;
+
+ // If the cursor has moved into a different excerpt, retrieve a new syntax layer
+ // from that buffer.
+ let buffer_state = editor_state
+ .active_buffer
+ .get_or_insert_with(|| BufferState {
+ buffer: buffer.clone(),
+ excerpt_id,
+ active_layer: None,
+ });
+ let mut prev_layer = None;
+ if did_reparse {
+ prev_layer = buffer_state.active_layer.take();
+ }
+ if buffer_state.buffer != buffer || buffer_state.excerpt_id != buffer_state.excerpt_id {
+ buffer_state.buffer = buffer.clone();
+ buffer_state.excerpt_id = excerpt_id;
+ buffer_state.active_layer = None;
+ }
+
+ let layer = match &mut buffer_state.active_layer {
+ Some(layer) => layer,
+ None => {
+ let snapshot = buffer.read(cx).snapshot();
+ let layer = if let Some(prev_layer) = prev_layer {
+ let prev_range = prev_layer.node().byte_range();
+ snapshot
+ .syntax_layers()
+ .filter(|layer| layer.language == &prev_layer.language)
+ .min_by_key(|layer| {
+ let range = layer.node().byte_range();
+ ((range.start as i64) - (prev_range.start as i64)).abs()
+ + ((range.end as i64) - (prev_range.end as i64)).abs()
+ })?
+ } else {
+ snapshot.syntax_layers().next()?
+ };
+ buffer_state.active_layer.insert(layer.to_owned())
+ }
+ };
+
+ // Within the active layer, find the syntax node under the cursor,
+ // and scroll to it.
+ let mut cursor = layer.node().walk();
+ while cursor.goto_first_child_for_byte(range.start).is_some() {
+ if !range.is_empty() && cursor.node().end_byte() == range.start {
+ cursor.goto_next_sibling();
+ }
+ }
+
+ // Ascend to the smallest ancestor that contains the range.
+ loop {
+ let node_range = cursor.node().byte_range();
+ if node_range.start <= range.start && node_range.end >= range.end {
+ break;
+ }
+ if !cursor.goto_parent() {
+ break;
+ }
+ }
+
+ let descendant_ix = cursor.descendant_index();
+ self.selected_descendant_ix = Some(descendant_ix);
+ self.list_scroll_handle.scroll_to_item(descendant_ix);
+
+ cx.notify();
+ Some(())
+ }
+
+ fn handle_click(&mut self, y: Pixels, cx: &mut ViewContext<SyntaxTreeView>) -> Option<()> {
+ let line_height = self.line_height?;
+ let ix = ((self.list_scroll_handle.scroll_top() + y) / line_height) as usize;
+
+ self.update_editor_with_range_for_descendant_ix(ix, cx, |editor, mut range, cx| {
+ // Put the cursor at the beginning of the node.
+ mem::swap(&mut range.start, &mut range.end);
+
+ editor.change_selections(Some(Autoscroll::newest()), cx, |selections| {
+ selections.select_ranges(vec![range]);
+ });
+ });
+ Some(())
+ }
+
+ fn hover_state_changed(&mut self, cx: &mut ViewContext<SyntaxTreeView>) {
+ if let Some((y, line_height)) = self.mouse_y.zip(self.line_height) {
+ let ix = ((self.list_scroll_handle.scroll_top() + y) / line_height) as usize;
+ if self.hovered_descendant_ix != Some(ix) {
+ self.hovered_descendant_ix = Some(ix);
+ self.update_editor_with_range_for_descendant_ix(ix, cx, |editor, range, cx| {
+ editor.clear_background_highlights::<Self>(cx);
+ editor.highlight_background::<Self>(
+ vec![range],
+ |theme| theme.editor_document_highlight_write_background,
+ cx,
+ );
+ });
+ cx.notify();
+ }
+ }
+ }
+
+ fn update_editor_with_range_for_descendant_ix(
+ &self,
+ descendant_ix: usize,
+ cx: &mut ViewContext<Self>,
+ mut f: impl FnMut(&mut Editor, Range<Anchor>, &mut ViewContext<Editor>),
+ ) -> Option<()> {
+ let editor_state = self.editor.as_ref()?;
+ let buffer_state = editor_state.active_buffer.as_ref()?;
+ let layer = buffer_state.active_layer.as_ref()?;
+
+ // Find the node.
+ let mut cursor = layer.node().walk();
+ cursor.goto_descendant(descendant_ix);
+ let node = cursor.node();
+ let range = node.byte_range();
+
+ // Build a text anchor range.
+ let buffer = buffer_state.buffer.read(cx);
+ let range = buffer.anchor_before(range.start)..buffer.anchor_after(range.end);
+
+ // Build a multibuffer anchor range.
+ let multibuffer = editor_state.editor.read(cx).buffer();
+ let multibuffer = multibuffer.read(cx).snapshot(cx);
+ let excerpt_id = buffer_state.excerpt_id;
+ let range = multibuffer.anchor_in_excerpt(excerpt_id, range.start)
+ ..multibuffer.anchor_in_excerpt(excerpt_id, range.end);
+
+ // Update the editor with the anchor range.
+ editor_state.editor.update(cx, |editor, cx| {
+ f(editor, range, cx);
+ });
+ Some(())
+ }
+
+ fn render_node(cursor: &TreeCursor, depth: u32, selected: bool, cx: &AppContext) -> Div {
+ let colors = cx.theme().colors();
+ let mut row = h_stack();
+ if let Some(field_name) = cursor.field_name() {
+ row = row.children([Label::new(field_name).color(Color::Info), Label::new(": ")]);
+ }
+
+ let node = cursor.node();
+ return row
+ .child(if node.is_named() {
+ Label::new(node.kind()).color(Color::Default)
+ } else {
+ Label::new(format!("\"{}\"", node.kind())).color(Color::Created)
+ })
+ .child(
+ div()
+ .child(Label::new(format_node_range(node)).color(Color::Muted))
+ .pl_1(),
+ )
+ .text_bg(if selected {
+ colors.element_selected
+ } else {
+ Hsla::default()
+ })
+ .pl(rems(depth as f32))
+ .hover(|style| style.bg(colors.element_hover));
+ }
+}
+
+impl Render for SyntaxTreeView {
+ type Element = Div;
+
+ fn render(&mut self, cx: &mut gpui::ViewContext<'_, Self>) -> Self::Element {
+ let settings = ThemeSettings::get_global(cx);
+ let line_height = cx
+ .text_style()
+ .line_height_in_pixels(settings.buffer_font_size(cx));
+ if Some(line_height) != self.line_height {
+ self.line_height = Some(line_height);
+ self.hover_state_changed(cx);
+ }
+
+ let mut rendered = div().flex_1();
+
+ if let Some(layer) = self
+ .editor
+ .as_ref()
+ .and_then(|editor| editor.active_buffer.as_ref())
+ .and_then(|buffer| buffer.active_layer.as_ref())
+ {
+ let layer = layer.clone();
+ let list = uniform_list(
+ cx.view().clone(),
+ "SyntaxTreeView",
+ layer.node().descendant_count(),
+ move |this, range, cx| {
+ let mut items = Vec::new();
+ let mut cursor = layer.node().walk();
+ let mut descendant_ix = range.start as usize;
+ cursor.goto_descendant(descendant_ix);
+ let mut depth = cursor.depth();
+ let mut visited_children = false;
+ while descendant_ix < range.end {
+ if visited_children {
+ if cursor.goto_next_sibling() {
+ visited_children = false;
+ } else if cursor.goto_parent() {
+ depth -= 1;
+ } else {
+ break;
+ }
+ } else {
+ items.push(Self::render_node(
+ &cursor,
+ depth,
+ Some(descendant_ix) == this.selected_descendant_ix,
+ cx,
+ ));
+ descendant_ix += 1;
+ if cursor.goto_first_child() {
+ depth += 1;
+ } else {
+ visited_children = true;
+ }
+ }
+ }
+ items
+ },
+ )
+ .size_full()
+ .track_scroll(self.list_scroll_handle.clone())
+ .on_mouse_move(cx.listener(move |tree_view, event: &MouseMoveEvent, cx| {
+ tree_view.mouse_y = Some(event.position.y);
+ tree_view.hover_state_changed(cx);
+ }))
+ .on_mouse_down(
+ MouseButton::Left,
+ cx.listener(move |tree_view, event: &MouseDownEvent, cx| {
+ tree_view.handle_click(event.position.y, cx);
+ }),
+ )
+ .text_bg(cx.theme().colors().background);
+
+ rendered = rendered.child(
+ canvas(move |bounds, cx| {
+ list.into_any_element().draw(
+ bounds.origin,
+ bounds.size.map(AvailableSpace::Definite),
+ cx,
+ )
+ })
+ .size_full(),
+ );
+ }
+
+ rendered
+ }
+}
+
+impl EventEmitter<()> for SyntaxTreeView {}
+
+impl FocusableView for SyntaxTreeView {
+ fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
+ self.focus_handle.clone()
+ }
+}
+
+impl Item for SyntaxTreeView {
+ type Event = ();
+
+ fn to_item_events(_: &Self::Event, _: impl FnMut(workspace::item::ItemEvent)) {}
+
+ fn tab_content(&self, _: Option<usize>, _: bool, _: &WindowContext<'_>) -> AnyElement {
+ Label::new("Syntax Tree").into_any_element()
+ }
+
+ fn clone_on_split(
+ &self,
+ _: workspace::WorkspaceId,
+ cx: &mut ViewContext<Self>,
+ ) -> Option<View<Self>>
+ where
+ Self: Sized,
+ {
+ Some(cx.build_view(|cx| {
+ let mut clone = Self::new(self.workspace_handle.clone(), None, cx);
+ if let Some(editor) = &self.editor {
+ clone.set_editor(editor.editor.clone(), cx)
+ }
+ clone
+ }))
+ }
+}
+
+impl SyntaxTreeToolbarItemView {
+ pub fn new() -> Self {
+ Self {
+ tree_view: None,
+ subscription: None,
+ }
+ }
+
+ fn render_menu(&mut self, cx: &mut ViewContext<'_, Self>) -> Option<PopoverMenu<ContextMenu>> {
+ let tree_view = self.tree_view.as_ref()?;
+ let tree_view = tree_view.read(cx);
+
+ let editor_state = tree_view.editor.as_ref()?;
+ let buffer_state = editor_state.active_buffer.as_ref()?;
+ let active_layer = buffer_state.active_layer.clone()?;
+ let active_buffer = buffer_state.buffer.read(cx).snapshot();
+
+ let view = cx.view().clone();
+ Some(
+ popover_menu("Syntax Tree")
+ .trigger(Self::render_header(&active_layer))
+ .menu(move |cx| {
+ ContextMenu::build(cx, |mut menu, cx| {
+ for (layer_ix, layer) in active_buffer.syntax_layers().enumerate() {
+ menu = menu.entry(
+ format!(
+ "{} {}",
+ layer.language.name(),
+ format_node_range(layer.node())
+ ),
+ cx.handler_for(&view, move |view, cx| {
+ view.select_layer(layer_ix, cx);
+ }),
+ );
+ }
+ menu
+ })
+ }),
+ )
+ }
+
+ fn select_layer(&mut self, layer_ix: usize, cx: &mut ViewContext<Self>) -> Option<()> {
+ let tree_view = self.tree_view.as_ref()?;
+ tree_view.update(cx, |view, cx| {
+ let editor_state = view.editor.as_mut()?;
+ let buffer_state = editor_state.active_buffer.as_mut()?;
+ let snapshot = buffer_state.buffer.read(cx).snapshot();
+ let layer = snapshot.syntax_layers().nth(layer_ix)?;
+ buffer_state.active_layer = Some(layer.to_owned());
+ view.selected_descendant_ix = None;
+ cx.notify();
+ view.focus_handle.focus(cx);
+ Some(())
+ })
+ }
+
+ fn render_header(active_layer: &OwnedSyntaxLayerInfo) -> ButtonLike {
+ ButtonLike::new("syntax tree header")
+ .child(Label::new(active_layer.language.name()))
+ .child(Label::new(format_node_range(active_layer.node())))
+ }
+}
+
+fn format_node_range(node: Node) -> String {
+ let start = node.start_position();
+ let end = node.end_position();
+ format!(
+ "[{}:{} - {}:{}]",
+ start.row + 1,
+ start.column + 1,
+ end.row + 1,
+ end.column + 1,
+ )
+}
+
+impl Render for SyntaxTreeToolbarItemView {
+ type Element = PopoverMenu<ContextMenu>;
+
+ fn render(&mut self, cx: &mut ViewContext<'_, Self>) -> PopoverMenu<ContextMenu> {
+ self.render_menu(cx)
+ .unwrap_or_else(|| popover_menu("Empty Syntax Tree"))
+ }
+}
+
+impl EventEmitter<ToolbarItemEvent> for SyntaxTreeToolbarItemView {}
+
+impl ToolbarItemView for SyntaxTreeToolbarItemView {
+ fn set_active_pane_item(
+ &mut self,
+ active_pane_item: Option<&dyn ItemHandle>,
+ cx: &mut ViewContext<Self>,
+ ) -> ToolbarItemLocation {
+ if let Some(item) = active_pane_item {
+ if let Some(view) = item.downcast::<SyntaxTreeView>() {
+ self.tree_view = Some(view.clone());
+ self.subscription = Some(cx.observe(&view, |_, _, cx| cx.notify()));
+ return ToolbarItemLocation::PrimaryLeft;
+ }
+ }
+ self.tree_view = None;
+ self.subscription = None;
+ ToolbarItemLocation::Hidden
+ }
+}
@@ -3,13 +3,13 @@ use crate::{
ListSeparator, ListSubHeader,
};
use gpui::{
- px, Action, AppContext, DismissEvent, Div, EventEmitter, FocusHandle, FocusableView,
- IntoElement, Render, Subscription, View, VisualContext,
+ px, Action, AnyElement, AppContext, DismissEvent, Div, EventEmitter, FocusHandle,
+ FocusableView, IntoElement, Render, Subscription, View, VisualContext,
};
use menu::{SelectFirst, SelectLast, SelectNext, SelectPrev};
use std::{rc::Rc, time::Duration};
-pub enum ContextMenuItem {
+enum ContextMenuItem {
Separator,
Header(SharedString),
Entry {
@@ -18,6 +18,10 @@ pub enum ContextMenuItem {
handler: Rc<dyn Fn(&mut WindowContext)>,
action: Option<Box<dyn Action>>,
},
+ CustomEntry {
+ entry_render: Box<dyn Fn(&mut WindowContext) -> AnyElement>,
+ handler: Rc<dyn Fn(&mut WindowContext)>,
+ },
}
pub struct ContextMenu {
@@ -83,6 +87,18 @@ impl ContextMenu {
self
}
+ pub fn custom_entry(
+ mut self,
+ entry_render: impl Fn(&mut WindowContext) -> AnyElement + 'static,
+ handler: impl Fn(&mut WindowContext) + 'static,
+ ) -> Self {
+ self.items.push(ContextMenuItem::CustomEntry {
+ entry_render: Box::new(entry_render),
+ handler: Rc::new(handler),
+ });
+ self
+ }
+
pub fn action(mut self, label: impl Into<SharedString>, action: Box<dyn Action>) -> Self {
self.items.push(ContextMenuItem::Entry {
label: label.into(),
@@ -104,11 +120,14 @@ impl ContextMenu {
}
pub fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
- if let Some(ContextMenuItem::Entry { handler, .. }) =
- self.selected_index.and_then(|ix| self.items.get(ix))
- {
- (handler)(cx)
+ match self.selected_index.and_then(|ix| self.items.get(ix)) {
+ Some(
+ ContextMenuItem::Entry { handler, .. }
+ | ContextMenuItem::CustomEntry { handler, .. },
+ ) => (handler)(cx),
+ _ => {}
}
+
cx.emit(DismissEvent);
}
@@ -122,14 +141,20 @@ impl ContextMenu {
cx.notify();
}
- fn select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
+ pub fn select_last(&mut self) -> Option<usize> {
for (ix, item) in self.items.iter().enumerate().rev() {
if item.is_selectable() {
self.selected_index = Some(ix);
- cx.notify();
- break;
+ return Some(ix);
}
}
+ None
+ }
+
+ fn handle_select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
+ if self.select_last().is_some() {
+ cx.notify();
+ }
}
fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
@@ -156,7 +181,7 @@ impl ContextMenu {
}
}
} else {
- self.select_last(&Default::default(), cx);
+ self.handle_select_last(&Default::default(), cx);
}
}
@@ -182,7 +207,7 @@ impl ContextMenu {
.await;
this.update(&mut cx, |this, cx| {
cx.dispatch_action(action);
- this.cancel(&Default::default(), cx)
+ this.cancel(&menu::Cancel, cx)
})
})
.detach_and_log_err(cx);
@@ -194,7 +219,7 @@ impl ContextMenu {
impl ContextMenuItem {
fn is_selectable(&self) -> bool {
- matches!(self, Self::Entry { .. })
+ matches!(self, Self::Entry { .. } | Self::CustomEntry { .. })
}
}
@@ -206,10 +231,10 @@ impl Render for ContextMenu {
v_stack()
.min_w(px(200.))
.track_focus(&self.focus_handle)
- .on_mouse_down_out(cx.listener(|this, _, cx| this.cancel(&Default::default(), cx)))
+ .on_mouse_down_out(cx.listener(|this, _, cx| this.cancel(&menu::Cancel, cx)))
.key_context("menu")
.on_action(cx.listener(ContextMenu::select_first))
- .on_action(cx.listener(ContextMenu::select_last))
+ .on_action(cx.listener(ContextMenu::handle_select_last))
.on_action(cx.listener(ContextMenu::select_next))
.on_action(cx.listener(ContextMenu::select_prev))
.on_action(cx.listener(ContextMenu::confirm))
@@ -230,50 +255,60 @@ impl Render for ContextMenu {
el
})
.flex_none()
- .child(
- List::new().children(self.items.iter().enumerate().map(
- |(ix, item)| match item {
- ContextMenuItem::Separator => ListSeparator.into_any_element(),
- ContextMenuItem::Header(header) => {
- ListSubHeader::new(header.clone()).into_any_element()
- }
- ContextMenuItem::Entry {
- label,
- handler,
- icon,
- action,
- } => {
- let handler = handler.clone();
-
- let label_element = if let Some(icon) = icon {
- h_stack()
- .gap_1()
- .child(Label::new(label.clone()))
- .child(IconElement::new(*icon))
- .into_any_element()
- } else {
- Label::new(label.clone()).into_any_element()
- };
+ .child(List::new().children(self.items.iter_mut().enumerate().map(
+ |(ix, item)| match item {
+ ContextMenuItem::Separator => ListSeparator.into_any_element(),
+ ContextMenuItem::Header(header) => {
+ ListSubHeader::new(header.clone()).into_any_element()
+ }
+ ContextMenuItem::Entry {
+ label,
+ handler,
+ icon,
+ action,
+ } => {
+ let handler = handler.clone();
- ListItem::new(label.clone())
- .inset(true)
- .selected(Some(ix) == self.selected_index)
- .on_click(move |_, cx| handler(cx))
- .child(
- h_stack()
- .w_full()
- .justify_between()
- .child(label_element)
- .children(action.as_ref().and_then(|action| {
- KeyBinding::for_action(&**action, cx)
- .map(|binding| div().ml_1().child(binding))
- })),
- )
+ let label_element = if let Some(icon) = icon {
+ h_stack()
+ .gap_1()
+ .child(Label::new(label.clone()))
+ .child(IconElement::new(*icon))
.into_any_element()
- }
- },
- )),
- ),
+ } else {
+ Label::new(label.clone()).into_any_element()
+ };
+
+ ListItem::new(ix)
+ .inset(true)
+ .selected(Some(ix) == self.selected_index)
+ .on_click(move |_, cx| handler(cx))
+ .child(
+ h_stack()
+ .w_full()
+ .justify_between()
+ .child(label_element)
+ .children(action.as_ref().and_then(|action| {
+ KeyBinding::for_action(&**action, cx)
+ .map(|binding| div().ml_1().child(binding))
+ })),
+ )
+ .into_any_element()
+ }
+ ContextMenuItem::CustomEntry {
+ entry_render,
+ handler,
+ } => {
+ let handler = handler.clone();
+ ListItem::new(ix)
+ .inset(true)
+ .selected(Some(ix) == self.selected_index)
+ .on_click(move |_, cx| handler(cx))
+ .child(entry_render(cx))
+ .into_any_element()
+ }
+ },
+ ))),
)
}
}
@@ -96,7 +96,6 @@ impl RenderOnce for TabBar {
div()
.id(self.id)
- .z_index(120) // todo!("z-index")
.group("tab_bar")
.flex()
.flex_none()
@@ -105,7 +105,6 @@ impl Render for Toolbar {
v_stack()
.p_1()
.gap_2()
- .z_index(80) // todo!("z-index")
.border_b()
.border_color(cx.theme().colors().border_variant)
.bg(cx.theme().colors().toolbar_background)
@@ -47,7 +47,7 @@ language = { package = "language2", path = "../language2" }
language_selector = { package = "language_selector2", path = "../language_selector2" }
lsp = { package = "lsp2", path = "../lsp2" }
menu = { package = "menu2", path = "../menu2" }
-# language_tools = { path = "../language_tools" }
+language_tools = { package = "language_tools2", path = "../language_tools2" }
node_runtime = { path = "../node_runtime" }
notifications = { package = "notifications2", path = "../notifications2" }
assistant = { package = "assistant2", path = "../assistant2" }
@@ -217,8 +217,7 @@ fn main() {
// journal2::init(app_state.clone(), cx);
language_selector::init(cx);
theme_selector::init(cx);
- // activity_indicator::init(cx);
- // language_tools::init(cx);
+ language_tools::init(cx);
call::init(app_state.client.clone(), app_state.user_store.clone(), cx);
notifications::init(app_state.client.clone(), app_state.user_store.clone(), cx);
collab_ui::init(&app_state, cx);
@@ -429,12 +429,11 @@ fn initialize_pane(workspace: &mut Workspace, pane: &View<Pane>, cx: &mut ViewCo
toolbar.add_item(diagnostic_editor_controls, cx);
let project_search_bar = cx.build_view(|_| ProjectSearchBar::new());
toolbar.add_item(project_search_bar, cx);
- // let lsp_log_item =
- // cx.add_view(|_| language_tools::LspLogToolbarItemView::new());
- // toolbar.add_item(lsp_log_item, cx);
- // let syntax_tree_item = cx
- // .add_view(|_| language_tools::SyntaxTreeToolbarItemView::new());
- // toolbar.add_item(syntax_tree_item, cx);
+ let lsp_log_item = cx.build_view(|_| language_tools::LspLogToolbarItemView::new());
+ toolbar.add_item(lsp_log_item, cx);
+ let syntax_tree_item =
+ cx.build_view(|_| language_tools::SyntaxTreeToolbarItemView::new());
+ toolbar.add_item(syntax_tree_item, cx);
})
});
}