Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Show runnable task results in gutter (#61095)
Ruslan Semagin6b594a43b0f6
diff --git a/crates/editor/src/code_actions.rs b/crates/editor/src/code_actions.rsindex a5d33926d0c..d98f903a3b2 100644--- a/crates/editor/src/code_actions.rs+++ b/crates/editor/src/code_actions.rs@@ -206,19 +206,52 @@ impl Editor {let action_ix = action.item_ix.unwrap_or(actions_menu.selected_item);let action = actions_menu.actions.get(action_ix)?;let title = action.label();+ let runnable_task_key =+ self.runnable_task_key_for_source(&actions_menu.deployed_from, window, cx);let buffer = actions_menu.buffer;let workspace = self.workspace()?;match action {CodeActionsItem::Task(task_source_kind, resolved_task) => {- workspace.update(cx, |workspace, cx| {- workspace.schedule_resolved_task(- task_source_kind,- resolved_task,- false,- window,+ if let Some((buffer_id, buffer_row)) = runnable_task_key {+ self.set_runnable_task_status(+ buffer_id,+ buffer_row,+ RunnableTaskStatus::Running,cx,);+ }+ let editor = cx.weak_entity();+ workspace.update(cx, |workspace, cx| {+ if let Some((buffer_id, buffer_row)) = runnable_task_key {+ workspace.schedule_resolved_task_with_completion(+ task_source_kind,+ resolved_task,+ false,+ move |result, cx| {+ editor+ .update(cx, |editor, cx| {+ editor.set_runnable_task_status(+ buffer_id,+ buffer_row,+ RunnableTaskStatus::from(result),+ cx,+ );+ })+ .ok();+ },+ window,+ cx,+ );+ } else {+ workspace.schedule_resolved_task(+ task_source_kind,+ resolved_task,+ false,+ window,+ cx,+ );+ }Some(Task::ready(Ok(())))})@@ -262,6 +295,25 @@ impl Editor {}}+ fn runnable_task_key_for_source(+ &self,+ source: &Option<CodeActionSource>,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) -> Option<(BufferId, BufferRow)> {+ let display_row = match source {+ Some(CodeActionSource::RunMenu(row)) => *row,+ _ => return None,+ };+ let snapshot = self.snapshot(window, cx);+ let multibuffer_row =+ MultiBufferRow(DisplayPoint::new(display_row, 0).to_point(&snapshot).row);+ let (buffer_snapshot, range) = snapshot+ .buffer_snapshot()+ .buffer_line_for_row(multibuffer_row)?;+ Some((buffer_snapshot.remote_id(), range.start.row))+ }+pub fn code_actions_enabled_for_toolbar(&self, cx: &App) -> bool {!self.code_action_providers.is_empty()&& EditorSettings::get_global(cx).toolbar.code_actionsdiff --git a/crates/editor/src/code_lens.rs b/crates/editor/src/code_lens.rsindex 3d262788af0..7e03e39255d 100644--- a/crates/editor/src/code_lens.rs+++ b/crates/editor/src/code_lens.rs@@ -5,7 +5,7 @@ use futures::{StreamExt as _, future::join_all, stream::FuturesUnordered};use gpui::{MouseButton, SharedString, Task, TaskExt, WeakEntity};use itertools::Itertools;use language::{BufferId, ClientCommand};-use multi_buffer::{Anchor, MultiBufferRow, MultiBufferSnapshot, ToPoint as _};+use multi_buffer::{Anchor, BufferOffset, MultiBufferRow, MultiBufferSnapshot, ToPoint as _};use project::{CodeAction, TaskSourceKind, lsp_store::code_lens::CodeLensActions};use task::TaskContext;use text::ToOffset as _;@@ -17,6 +17,7 @@ use crate::{actions::ToggleCodeLens,display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId, RenderBlock},hover_links::HoverLink,+ runnables::RunnableTaskStatus,};static EMPTY_LENS_FALLBACK_TITLE: SharedString = SharedString::new_static("0 references");@@ -97,7 +98,7 @@ pub(super) fn try_handle_client_command(fn schedule_task(task_template: task::TaskTemplate,action: &CodeAction,- editor: &Editor,+ editor: &mut Editor,workspace: &gpui::Entity<workspace::Workspace>,window: &mut Window,cx: &mut Context<Editor>,@@ -127,15 +128,49 @@ fn schedule_task(},};+ let Some(resolved_task) =+ task_template.resolve_task(&task_source_kind.to_id_base(), &task_context)+ else {+ return true;+ };+ let runnable_task_key = editor+ .buffer()+ .read(cx)+ .buffer(action.range.start.buffer_id)+ .and_then(|buffer| {+ let buffer_snapshot = buffer.read(cx).snapshot();+ let buffer_id = buffer_snapshot.remote_id();+ let offset = BufferOffset(action.range.start.to_offset(&buffer_snapshot));+ editor.runnable_task_key_for_offset(buffer_id, offset)+ });+ if let Some((buffer_id, buffer_row)) = runnable_task_key {+ editor.set_runnable_task_status(buffer_id, buffer_row, RunnableTaskStatus::Running, cx);+ }+ let editor_handle = cx.weak_entity();workspace.update(cx, |workspace, cx| {- workspace.schedule_task(- task_source_kind,- &task_template,- &task_context,- false,- window,- cx,- );+ if let Some((buffer_id, buffer_row)) = runnable_task_key {+ workspace.schedule_resolved_task_with_completion(+ task_source_kind,+ resolved_task,+ false,+ move |result, cx| {+ editor_handle+ .update(cx, |editor, cx| {+ editor.set_runnable_task_status(+ buffer_id,+ buffer_row,+ RunnableTaskStatus::from(result),+ cx,+ );+ })+ .ok();+ },+ window,+ cx,+ );+ } else {+ workspace.schedule_resolved_task(task_source_kind, resolved_task, false, window, cx);+ }});true}diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rsindex f456d62a22e..6f8fec7b376 100644--- a/crates/editor/src/editor.rs+++ b/crates/editor/src/editor.rs@@ -282,7 +282,7 @@ use crate::{InlineValueCache,inlay_hints::{LspInlayHintData, inlay_hint_settings},},- runnables::{ResolvedTasks, RunnableData, RunnableTasks},+ runnables::{ResolvedTasks, RunnableData, RunnableTaskStatus, RunnableTasks},scroll::{ScrollOffset, ScrollPixelOffset},selections_collection::resolve_selections_wrapping_blocks,semantic_tokens::SemanticTokenState,diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rsindex 6fa72f155f8..bfc39e3f465 100644--- a/crates/editor/src/element.rs+++ b/crates/editor/src/element.rs@@ -2611,6 +2611,14 @@ impl EditorElement {run_indicators.iter().filter_map(|display_row| {+ let task_status = gutter+ .row_infos+ .get((display_row.0.saturating_sub(gutter.range.start.0)) as usize)+ .and_then(|row_info| Some((row_info.buffer_id?, row_info.buffer_row?)))+ .and_then(|(buffer_id, buffer_row)| {+ editor.runnable_task_status(buffer_id, buffer_row)+ });+gutter.layout_item(*display_row,|cx, _| {@@ -2619,6 +2627,7 @@ impl EditorElement {&self.style,Some(*display_row) == active_task_indicator_row,breakpoints.get(&display_row).map(|(anchor, _, _)| *anchor),+ task_status,*display_row,cx,)diff --git a/crates/editor/src/runnables.rs b/crates/editor/src/runnables.rsindex a0e1f585617..7e0cc27706f 100644--- a/crates/editor/src/runnables.rs+++ b/crates/editor/src/runnables.rs@@ -24,6 +24,7 @@ use crate::{#[derive(Debug)]pub(super) struct RunnableData {runnables: HashMap<BufferId, (Global, BTreeMap<BufferRow, RunnableTasks>)>,+ task_statuses: HashMap<(BufferId, BufferRow), RunnableTaskStatus>,invalidate_buffer_data: HashSet<BufferId>,runnables_update_task: Task<()>,}@@ -32,6 +33,7 @@ impl RunnableData {pub fn new() -> Self {Self {runnables: HashMap::default(),+ task_statuses: HashMap::default(),invalidate_buffer_data: HashSet::default(),runnables_update_task: Task::ready(()),}@@ -50,6 +52,38 @@ impl RunnableData {.flat_map(|(_, tasks)| tasks.values())}+ pub fn task_status(+ &self,+ (buffer_id, buffer_row): (BufferId, BufferRow),+ ) -> Option<RunnableTaskStatus> {+ self.task_statuses.get(&(buffer_id, buffer_row)).copied()+ }++ pub fn set_task_status(+ &mut self,+ (buffer_id, buffer_row): (BufferId, BufferRow),+ status: RunnableTaskStatus,+ ) {+ self.task_statuses.insert((buffer_id, buffer_row), status);+ }++ pub fn task_key_for_offset(+ &self,+ buffer_id: BufferId,+ offset: BufferOffset,+ ) -> Option<(BufferId, BufferRow)> {+ let (_, tasks_by_row) = self.runnables.get(&buffer_id)?;+ tasks_by_row+ .iter()+ .find(|(_, tasks)| tasks.context_range.contains(&offset))+ .or_else(|| {+ tasks_by_row+ .iter()+ .find(|(_, tasks)| tasks.context_range.start >= offset)+ })+ .map(|(row, _)| (buffer_id, *row))+ }+pub fn has_cached(&self, buffer_id: BufferId, version: &Global) -> bool {self.runnables.get(&buffer_id)@@ -72,6 +106,24 @@ impl RunnableData {}}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum RunnableTaskStatus {+ Running,+ Passed,+ Failed,+}++impl From<workspace::tasks::ScheduledTaskResult> for RunnableTaskStatus {+ fn from(result: workspace::tasks::ScheduledTaskResult) -> Self {+ match result {+ workspace::tasks::ScheduledTaskResult::Success => Self::Passed,+ workspace::tasks::ScheduledTaskResult::Failure+ | workspace::tasks::ScheduledTaskResult::SpawnFailed+ | workspace::tasks::ScheduledTaskResult::Cancelled => Self::Failed,+ }+ }+}+#[derive(Clone, Debug)]pub struct RunnableTasks {pub templates: Vec<(TaskSourceKind, TaskTemplate)>,@@ -307,6 +359,8 @@ impl Editor {return;};+ let buffer_id = buffer.read(cx).remote_id();+ let editor = cx.weak_entity();let reveal_strategy = action.reveal;let task_context = Self::build_tasks_context(&project, &buffer, buffer_row, &tasks, cx);cx.spawn_in(window, async move |_, cx| {@@ -316,12 +370,34 @@ impl Editor {let resolved = &mut resolved_task.resolved;resolved.reveal = reveal_strategy;+ editor+ .update(cx, |editor, cx| {+ editor.set_runnable_task_status(+ buffer_id,+ buffer_row,+ RunnableTaskStatus::Running,+ cx,+ );+ })+ .ok();workspace.update_in(cx, |workspace, window, cx| {- workspace.schedule_resolved_task(+ workspace.schedule_resolved_task_with_completion(task_source_kind,resolved_task,false,+ move |result, cx| {+ editor+ .update(cx, |editor, cx| {+ editor.set_runnable_task_status(+ buffer_id,+ buffer_row,+ RunnableTaskStatus::from(result),+ cx,+ );+ })+ .ok();+ },window,cx,);@@ -334,13 +410,45 @@ impl Editor {pub fn clear_runnables(&mut self, for_buffer: Option<BufferId>) {if let Some(buffer_id) = for_buffer {self.runnables.runnables.remove(&buffer_id);+ self.runnables+ .task_statuses+ .retain(|(status_buffer_id, _), _| *status_buffer_id != buffer_id);} else {self.runnables.runnables.clear();+ self.runnables.task_statuses.clear();}self.runnables.invalidate_buffer_data.clear();self.runnables.runnables_update_task = Task::ready(());}+ pub(crate) fn runnable_task_status(+ &self,+ buffer_id: BufferId,+ buffer_row: BufferRow,+ ) -> Option<RunnableTaskStatus> {+ self.runnables.task_status((buffer_id, buffer_row))+ }++ pub(crate) fn set_runnable_task_status(+ &mut self,+ buffer_id: BufferId,+ buffer_row: BufferRow,+ status: RunnableTaskStatus,+ cx: &mut Context<Self>,+ ) {+ self.runnables+ .set_task_status((buffer_id, buffer_row), status);+ cx.notify();+ }++ pub(crate) fn runnable_task_key_for_offset(+ &self,+ buffer_id: BufferId,+ offset: BufferOffset,+ ) -> Option<(BufferId, BufferRow)> {+ self.runnables.task_key_for_offset(buffer_id, offset)+ }+pub fn task_context(&self, window: &mut Window, cx: &mut App) -> Task<Option<TaskContext>> {let Some(project) = self.project.clone() else {return Task::ready(None);@@ -515,44 +623,53 @@ impl Editor {None}- pub fn render_run_indicator(+ pub(crate) fn render_run_indicator(&self,_style: &EditorStyle,is_active: bool,active_breakpoint: Option<Anchor>,+ task_status: Option<RunnableTaskStatus>,row: DisplayRow,cx: &mut Context<Self>,) -> IconButton {- let color = Color::Muted;+ let (icon, color) = match task_status {+ Some(RunnableTaskStatus::Running) => (ui::IconName::PlayOutlined, Color::Accent),+ Some(RunnableTaskStatus::Passed) => (ui::IconName::Check, Color::Success),+ Some(RunnableTaskStatus::Failed) => (ui::IconName::XCircle, Color::Error),+ None => (ui::IconName::PlayOutlined, Color::Muted),+ };- IconButton::new(- ("run_indicator", row.0 as usize),- ui::IconName::PlayOutlined,- )- .shape(ui::IconButtonShape::Square)- .icon_size(IconSize::XSmall)- .icon_color(color)- .toggle_state(is_active)- .on_click(cx.listener(move |editor, e: &ClickEvent, window, cx| {- let quick_launch = match e {- ClickEvent::Keyboard(_) => true,- ClickEvent::Mouse(e) => e.down.button == MouseButton::Left,- ClickEvent::Touch(_) => true,- };+ IconButton::new(("run_indicator", row.0 as usize), icon)+ .shape(ui::IconButtonShape::Square)+ .icon_size(IconSize::XSmall)+ .icon_color(color)+ .toggle_state(is_active)+ .on_click(cx.listener(move |editor, e: &ClickEvent, window, cx| {+ let quick_launch = match e {+ ClickEvent::Keyboard(_) => true,+ ClickEvent::Mouse(e) => e.down.button == MouseButton::Left,+ ClickEvent::Touch(_) => true,+ };- window.focus(&editor.focus_handle(cx), cx);- editor.toggle_code_actions(- &ToggleCodeActions {- deployed_from: Some(CodeActionSource::RunMenu(row)),- quick_launch,- },- window,- cx,- );- }))- .on_right_click(cx.listener(move |editor, event: &ClickEvent, window, cx| {- editor.set_gutter_context_menu(row, active_breakpoint, event.position(), window, cx);- }))+ window.focus(&editor.focus_handle(cx), cx);+ editor.toggle_code_actions(+ &ToggleCodeActions {+ deployed_from: Some(CodeActionSource::RunMenu(row)),+ quick_launch,+ },+ window,+ cx,+ );+ }))+ .on_right_click(cx.listener(move |editor, event: &ClickEvent, window, cx| {+ editor.set_gutter_context_menu(+ row,+ active_breakpoint,+ event.position(),+ window,+ cx,+ );+ }))}fn insert_runnables(diff --git a/crates/workspace/src/tasks.rs b/crates/workspace/src/tasks.rsindex 501fc583f2d..7bc6420c4c7 100644--- a/crates/workspace/src/tasks.rs+++ b/crates/workspace/src/tasks.rs@@ -15,6 +15,16 @@ use util::TryFutureExt;use crate::{SaveIntent, Toast, Workspace, notifications::NotificationId};+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum ScheduledTaskResult {+ Success,+ Failure,+ SpawnFailed,+ Cancelled,+}++type TaskCompletionHandler = Box<dyn FnOnce(ScheduledTaskResult, &mut AsyncWindowContext)>;+impl Workspace {pub fn schedule_task(self: &mut Workspace,@@ -58,6 +68,44 @@ impl Workspace {omit_history: bool,window: &mut Window,cx: &mut Context<Workspace>,+ ) {+ self.schedule_resolved_task_internal(+ task_source_kind,+ resolved_task,+ omit_history,+ None,+ window,+ cx,+ );+ }++ pub fn schedule_resolved_task_with_completion(+ self: &mut Workspace,+ task_source_kind: TaskSourceKind,+ resolved_task: ResolvedTask,+ omit_history: bool,+ on_complete: impl FnOnce(ScheduledTaskResult, &mut AsyncWindowContext) + 'static,+ window: &mut Window,+ cx: &mut Context<Workspace>,+ ) {+ self.schedule_resolved_task_internal(+ task_source_kind,+ resolved_task,+ omit_history,+ Some(Box::new(on_complete)),+ window,+ cx,+ );+ }++ fn schedule_resolved_task_internal(+ self: &mut Workspace,+ task_source_kind: TaskSourceKind,+ resolved_task: ResolvedTask,+ omit_history: bool,+ on_complete: Option<TaskCompletionHandler>,+ window: &mut Window,+ cx: &mut Context<Workspace>,) {let spawn_in_terminal = resolved_task.resolved.clone();if !omit_history {@@ -90,12 +138,14 @@ impl Workspace {});if let Some(spawn_task) = spawn_task.ok().flatten() {let res = cx.background_spawn(spawn_task).await;- match res {+ let result = match res {Some(Ok(status)) => {if status.success() {log::debug!("Task spawn succeeded");+ ScheduledTaskResult::Success} else {log::debug!("Task spawn failed, code: {:?}", status.code());+ ScheduledTaskResult::Failure}}Some(Err(e)) => {@@ -103,10 +153,19 @@ impl Workspace {_ = workspace.update(cx, |w, cx| {let id = NotificationId::unique::<ResolvedTask>();w.show_toast(Toast::new(id, format!("Task spawn failed: {e}")), cx);- })+ });+ ScheduledTaskResult::SpawnFailed+ }+ None => {+ log::debug!("Task spawn got cancelled");+ ScheduledTaskResult::Cancelled}- None => log::debug!("Task spawn got cancelled"),};+ if let Some(on_complete) = on_complete {+ on_complete(result, cx);+ }+ } else if let Some(on_complete) = on_complete {+ on_complete(ScheduledTaskResult::Cancelled, cx);}});self.scheduled_tasks.push(task);@@ -360,6 +419,30 @@ mod tests {assert!(cx.read(|cx| fixture.item.read(cx).is_dirty));}+ #[gpui::test]+ async fn test_schedule_resolved_task_with_completion_reports_success(cx: &mut TestAppContext) {+ let (fixture, cx) = create_fixture(cx, SaveStrategy::None).await;+ let task_result = Arc::new(Mutex::new(None));+ fixture.workspace.update_in(cx, |workspace, window, cx| {+ workspace.schedule_resolved_task_with_completion(+ TaskSourceKind::UserInput,+ fixture.task,+ false,+ {+ let task_result = task_result.clone();+ move |result, _| {+ *task_result.lock() = Some(result);+ }+ },+ window,+ cx,+ );+ });+ cx.executor().run_until_parked();++ assert_eq!(*task_result.lock(), Some(ScheduledTaskResult::Success));+ }+async fn create_fixture(cx: &mut TestAppContext,save_strategy: SaveStrategy,