`, but needs info for user defined components
- if !buffer
- .text_for_range(node.byte_range())
- .all(|str| str.chars().all(|c| c.is_lowercase()))
- {
- return false;
- }
- true
-}
-
-fn is_tombi_lsp_in_toml(
- project: &Project,
- buffer: &Entity
,
- cx: &mut Context,
-) -> bool {
- buffer.update(cx, |buffer, cx| {
- if !buffer.language().is_some_and(|lang| lang.name() == "TOML") {
- return false;
- }
- project.lsp_store().update(cx, |lsp_store, cx| {
- for (_, lsp) in lsp_store.running_language_servers_for_local_buffer(buffer, cx) {
- if "tombi".eq_ignore_ascii_case(lsp.name().as_ref()) {
- return true;
- }
- }
- false
- })
- })
-}
diff --git a/crates/editor/src/code_lens.rs b/crates/editor/src/code_lens.rs
index 87d2426878e..c1bf2525d9e 100644
--- a/crates/editor/src/code_lens.rs
+++ b/crates/editor/src/code_lens.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{iter, ops::Range, sync::Arc};
use collections::{HashMap, HashSet};
use futures::future::join_all;
@@ -7,15 +7,17 @@ use itertools::Itertools;
use language::{BufferId, ClientCommand};
use multi_buffer::{Anchor, MultiBufferRow, MultiBufferSnapshot, ToPoint as _};
use project::{CodeAction, TaskSourceKind};
+use settings::Settings as _;
use task::TaskContext;
+use text::Point;
use ui::{Context, Window, div, prelude::*};
+use workspace::PreviewTabsSettings;
use crate::{
- Editor, LSP_REQUEST_DEBOUNCE_TIMEOUT, SelectionEffects,
+ Editor, LSP_REQUEST_DEBOUNCE_TIMEOUT, MultibufferSelectionMode, SelectionEffects,
actions::ToggleCodeLens,
display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId},
- hover_links::HoverLink,
};
#[derive(Clone, Debug)]
@@ -76,7 +78,6 @@ fn group_lenses_by_row(
}
fn render_code_lens_line(
- buffer_id: BufferId,
line_number: usize,
lens: CodeLensLine,
editor: WeakEntity,
@@ -103,11 +104,11 @@ fn render_code_lens_line(
let action = item.action.clone();
let editor_handle = editor.clone();
let position = lens.position;
- let id = SharedString::from(format!("{buffer_id}:{line_number}:{i}"));
+ let id = (line_number as u64) << 32 | (i as u64);
children.push(
div()
- .id(ElementId::Name(id))
+ .id(ElementId::Integer(id))
.font(font.clone())
.text_size(font_size)
.text_color(cx.app.theme().colors().text_muted)
@@ -205,7 +206,7 @@ pub(super) fn try_handle_client_command(
schedule_task(task_template, action, editor, workspace, window, cx)
}
Some(ClientCommand::ShowLocations) => {
- try_show_references(arguments, action, editor, window, cx)
+ try_show_references(arguments, action, workspace, window, cx)
}
None => false,
}
@@ -260,7 +261,7 @@ fn schedule_task(
fn try_show_references(
arguments: &[serde_json::Value],
action: &CodeAction,
- editor: &mut Editor,
+ workspace: &gpui::Entity,
window: &mut Window,
cx: &mut Context,
) -> bool {
@@ -275,18 +276,73 @@ fn try_show_references(
}
let server_id = action.server_id;
- let nav_entry = editor.navigation_entry(editor.selections.newest_anchor().head(), cx);
- let links = locations
- .into_iter()
- .map(|location| HoverLink::InlayHint(location, server_id))
- .collect();
- editor
- .navigate_to_hover_links(None, links, nav_entry, false, window, cx)
- .detach_and_log_err(cx);
+ let project = workspace.read(cx).project().clone();
+ let workspace = workspace.clone();
+
+ cx.spawn_in(window, async move |_editor, cx| {
+ let mut buffer_locations = std::collections::HashMap::default();
+
+ for location in &locations {
+ let open_task = cx.update(|_, cx| {
+ project.update(cx, |project, cx| {
+ let uri: lsp::Uri = location.uri.clone();
+ project.open_local_buffer_via_lsp(uri, server_id, cx)
+ })
+ })?;
+ let buffer = open_task.await?;
+
+ let range = range_from_lsp(location.range);
+ buffer_locations
+ .entry(buffer)
+ .or_insert_with(Vec::new)
+ .push(range);
+ }
+
+ workspace.update_in(cx, |workspace, window, cx| {
+ let target = buffer_locations
+ .iter()
+ .flat_map(|(k, v)| iter::repeat(k.clone()).zip(v))
+ .map(|(buffer, location)| {
+ buffer
+ .read(cx)
+ .text_for_range(location.clone())
+ .collect::()
+ })
+ .filter(|text| !text.contains('\n'))
+ .unique()
+ .take(3)
+ .join(", ");
+ let title = if target.is_empty() {
+ "References".to_owned()
+ } else {
+ format!("References to {target}")
+ };
+ let allow_preview =
+ PreviewTabsSettings::get_global(cx).enable_preview_multibuffer_from_code_navigation;
+ Editor::open_locations_in_multibuffer(
+ workspace,
+ buffer_locations,
+ title,
+ false,
+ allow_preview,
+ MultibufferSelectionMode::First,
+ window,
+ cx,
+ );
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
true
}
+fn range_from_lsp(range: lsp::Range) -> Range {
+ let start = Point::new(range.start.line, range.start.character);
+ let end = Point::new(range.end.line, range.end.character);
+ start..end
+}
+
impl Editor {
pub(super) fn refresh_code_lenses(
&mut self,
@@ -413,7 +469,6 @@ impl Editor {
height: Some(1),
style: BlockStyle::Flex,
render: Arc::new(render_code_lens_line(
- buffer_id,
line_number,
lens_line,
editor_handle.clone(),
@@ -554,7 +609,6 @@ impl Editor {
height: Some(1),
style: BlockStyle::Flex,
render: Arc::new(render_code_lens_line(
- buffer_id,
line_number,
lens_line,
editor_handle.clone(),
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 9102fc428f6..b01d1592abb 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -3860,6 +3860,9 @@ impl Editor {
cx.emit(EditorEvent::SelectionsChanged { local });
let selections = &self.selections.disjoint_anchors_arc();
+ if selections.len() == 1 {
+ cx.emit(SearchEvent::ActiveMatchChanged)
+ }
if local && let Some(buffer_snapshot) = buffer.as_singleton() {
let inmemory_selections = selections
.iter()
@@ -9255,9 +9258,9 @@ impl Editor {
}))
.tooltip(move |_window, cx| {
Tooltip::with_meta_in(
- "Remove Bookmark",
+ "Remove bookmark",
Some(&ToggleBookmark),
- SharedString::from("Right-click for more options"),
+ SharedString::from("Right-click for more options."),
&focus_handle,
cx,
)
@@ -9543,16 +9546,15 @@ impl Editor {
};
let primary_action_text = "Unset breakpoint";
let focus_handle = self.focus_handle.clone();
- let has_context_menu = self.has_mouse_context_menu();
let meta = if is_rejected {
SharedString::from("No executable code is associated with this line.")
} else if !breakpoint.is_disabled() {
SharedString::from(format!(
- "{alt_as_text}-click to disable\nright-click for more options"
+ "{alt_as_text}click to disable,\nright-click for more options."
))
} else {
- SharedString::from("Right-click for more options")
+ SharedString::from("Right-click for more options.")
};
IconButton::new(("breakpoint_indicator", row.0 as usize), icon)
.icon_size(IconSize::XSmall)
@@ -9582,16 +9584,14 @@ impl Editor {
.on_right_click(cx.listener(move |editor, event: &ClickEvent, window, cx| {
editor.set_gutter_context_menu(row, Some(position), event.position(), window, cx);
}))
- .when(!has_context_menu, |button| {
- button.tooltip(move |_window, cx| {
- Tooltip::with_meta_in(
- primary_action_text,
- Some(&ToggleBreakpoint),
- meta.clone(),
- &focus_handle,
- cx,
- )
- })
+ .tooltip(move |_window, cx| {
+ Tooltip::with_meta_in(
+ primary_action_text,
+ Some(&ToggleBreakpoint),
+ meta.clone(),
+ &focus_handle,
+ cx,
+ )
})
}
@@ -9637,10 +9637,10 @@ impl Editor {
};
match self {
Intent::SetBookmark => format!(
- "{alt_as_text}-click to add a breakpoint\nright-click for more options"
+ "{alt_as_text}click to add a breakpoint,\nright-click for more options."
),
Intent::SetBreakpoint => format!(
- "{alt_as_text}-click to add a bookmark\nright-click for more options"
+ "{alt_as_text}click to add a bookmark,\nright-click for more options."
),
}
}
@@ -9667,7 +9667,6 @@ impl Editor {
};
let focus_handle = self.focus_handle.clone();
- let has_context_menu = self.has_mouse_context_menu();
IconButton::new(("add_breakpoint_button", row.0 as usize), intent.icon())
.icon_size(IconSize::XSmall)
.size(ui::ButtonSize::None)
@@ -9696,16 +9695,14 @@ impl Editor {
.on_right_click(cx.listener(move |editor, event: &ClickEvent, window, cx| {
editor.set_gutter_context_menu(row, Some(position), event.position(), window, cx);
}))
- .when(!has_context_menu, |button| {
- button.tooltip(move |_window, cx| {
- Tooltip::with_meta_in(
- intent.as_str(),
- Some(&ToggleBreakpoint),
- intent.secondary_and_options(),
- &focus_handle,
- cx,
- )
- })
+ .tooltip(move |_window, cx| {
+ Tooltip::with_meta_in(
+ intent.as_str(),
+ Some(&ToggleBreakpoint),
+ intent.secondary_and_options(),
+ &focus_handle,
+ cx,
+ )
})
}
@@ -16013,7 +16010,7 @@ impl Editor {
}
}
- pub(crate) fn navigation_entry(
+ fn navigation_entry(
&self,
cursor_anchor: Anchor,
cx: &mut Context,
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 025cd4251ad..6dfbf334024 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -3,7 +3,7 @@ use crate::{
JoinLines,
code_context_menus::CodeContextMenu,
edit_prediction_tests::FakeEditPredictionDelegate,
- element::{StickyHeader, header_jump_data},
+ element::StickyHeader,
linked_editing_ranges::LinkedEditingRanges,
runnables::RunnableTasks,
scroll::scroll_amount::ScrollAmount,
@@ -19335,112 +19335,6 @@ fn test_editing_disjoint_excerpts(cx: &mut TestAppContext) {
});
}
-#[gpui::test]
-fn test_header_jump_data_uses_selection_excerpt(cx: &mut TestAppContext) {
- init_test(cx, |_| {});
-
- // 25-line buffer so excerpts at rows 1, 10, and 20 (each a 1-line range,
- // expanded by 2 context lines) can't merge into a single excerpt.
- let buffer_text = (0..25)
- .map(|row| format!("line {row}"))
- .collect::>()
- .join("\n");
- let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));
- let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());
-
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(ReadWrite);
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer.clone(),
- [
- Point::new(1, 0)..Point::new(1, 0),
- Point::new(10, 0)..Point::new(10, 0),
- Point::new(20, 0)..Point::new(20, 0),
- ],
- 2,
- cx,
- );
- multibuffer
- });
-
- let (editor, cx) = cx.add_window_view(|window, cx| build_editor(multibuffer, window, cx));
-
- editor.update_in(cx, |editor, window, cx| {
- let snapshot = editor.snapshot(window, cx);
- let display_snapshot = editor.display_snapshot(cx);
-
- // Ensure the three ranges landed in three separate excerpts.
- let excerpts: Vec<_> = snapshot
- .buffer_snapshot()
- .excerpts_for_buffer(buffer_id)
- .collect();
- assert_eq!(excerpts.len(), 3);
-
- // Place the cursor at the start of the third excerpt, expressed in
- // terms of the underlying buffer.
- let selection_buffer_row = 20;
- let buffer_entity = editor.buffer().read(cx).buffer(buffer_id).unwrap();
- let selection_anchor = editor.buffer().update(cx, |multibuffer, cx| {
- multibuffer
- .buffer_point_to_anchor(&buffer_entity, Point::new(selection_buffer_row, 0), cx)
- .expect("buffer row 20 maps to a multibuffer anchor")
- });
- editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
- s.select_anchor_ranges([selection_anchor..selection_anchor])
- });
-
- let mut latest_selection_anchors: HashMap = HashMap::default();
- for selection in editor.selections.all_anchors(&display_snapshot).iter() {
- let head = selection.head();
- if let Some((text_anchor, _)) = snapshot.buffer_snapshot().anchor_to_buffer_anchor(head)
- {
- latest_selection_anchors.insert(text_anchor.buffer_id, head);
- }
- }
-
- // The sticky buffer header represents the FIRST excerpt of its buffer,
- // even when the cursor is in a later excerpt. That mismatch is the
- // precondition for the regression.
- let first_excerpt = snapshot
- .buffer_snapshot()
- .excerpt_boundaries_in_range(MultiBufferOffset(0)..snapshot.buffer_snapshot().len())
- .next()
- .expect("multibuffer has at least one excerpt")
- .next;
-
- let jump_data = header_jump_data(
- &snapshot,
- DisplayRow(0),
- FILE_HEADER_HEIGHT + MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
- &first_excerpt,
- &latest_selection_anchors,
- );
-
- match jump_data {
- JumpData::MultiBufferPoint {
- position,
- line_offset_from_top,
- ..
- } => {
- assert_eq!(
- position.row, selection_buffer_row,
- "jump should target the cursor's buffer row, not the first excerpt's row"
- );
- assert!(
- line_offset_from_top < selection_buffer_row,
- "line_offset_from_top ({line_offset_from_top}) should be measured from the \
- selection's excerpt, not the first excerpt; expected less than \
- selection_buffer_row ({selection_buffer_row})"
- );
- }
- JumpData::MultiBufferRow { .. } => {
- panic!("expected MultiBufferPoint jump data when a selection is present")
- }
- }
- });
-}
-
#[gpui::test]
async fn test_extra_newline_insertion(cx: &mut TestAppContext) {
init_test(cx, |_| {});
@@ -32821,78 +32715,6 @@ async fn test_sticky_scroll(cx: &mut TestAppContext) {
assert_eq!(sticky_headers(10.0), vec![]);
}
-#[gpui::test]
-async fn test_sticky_scroll_with_decoration_prefix_in_item(cx: &mut TestAppContext) {
- init_test(cx, |_| {});
- let mut cx = EditorTestContext::new(cx).await;
-
- let language = Arc::new(
- Language::new(
- LanguageConfig {
- name: "TypeScript".into(),
- ..Default::default()
- },
- Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
- )
- .with_outline_query(
- r#"
- (class_declaration
- "class" @context
- name: (_) @name) @item
- "#,
- )
- .expect("TypeScript outline query"),
- );
-
- let buffer = indoc! {"
- ˇ@Decorator
- class Foo {
- x = 1;
- y = 2;
- z = 3;
- w = 4;
- }
- "};
- cx.set_state(buffer);
- cx.update_editor(|e, _, cx| {
- e.buffer()
- .read(cx)
- .as_singleton()
- .unwrap()
- .update(cx, |buffer, cx| {
- buffer.set_language(Some(language), cx);
- })
- });
-
- let mut sticky_headers = |offset: ScrollOffset| {
- cx.update_editor(|e, window, cx| {
- e.scroll(gpui::Point { x: 0., y: offset }, None, window, cx);
- });
- cx.run_until_parked();
- cx.update_editor(|e, window, cx| {
- EditorElement::sticky_headers(&e, &e.snapshot(window, cx))
- .into_iter()
- .map(
- |StickyHeader {
- start_point,
- offset,
- ..
- }| { (start_point, offset) },
- )
- .collect::>()
- })
- };
-
- let class_foo = Point { row: 1, column: 0 };
-
- assert_eq!(sticky_headers(0.0), vec![]);
- assert_eq!(sticky_headers(1.5), vec![(class_foo, 0.0)]);
- assert_eq!(sticky_headers(2.5), vec![(class_foo, 0.0)]);
- assert_eq!(sticky_headers(5.5), vec![(class_foo, -0.5)]);
- assert_eq!(sticky_headers(6.0), vec![]);
- assert_eq!(sticky_headers(7.0), vec![]);
-}
-
#[gpui::test]
async fn test_sticky_scroll_with_expanded_deleted_diff_hunks(
executor: BackgroundExecutor,
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 1cefd2179b7..0646bf7a068 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -895,8 +895,7 @@ impl EditorElement {
let hitbox = &position_map.gutter_hitbox;
if event.position.x <= hitbox.bounds.right() - gutter_right_padding
- // Don't show the gutter_context_menu in collab notes
- && editor.project.is_some()
+ && editor.collaboration_hub.is_none()
{
let point_for_position = position_map.point_for_position(event.position);
editor.set_gutter_context_menu(
@@ -1395,7 +1394,7 @@ impl EditorElement {
indicator.is_active && start_row == valid_point.row()
});
- let gutter_hover_button = if gutter_hovered
+ let breakpoint_indicator = if gutter_hovered
&& !is_on_diff_review_button_row
&& split_side != Some(SplitSide::Left)
{
@@ -1440,16 +1439,13 @@ impl EditorElement {
editor.gutter_hover_button.1 = None;
None
}
- } else if editor.has_mouse_context_menu() {
- editor.gutter_hover_button.1 = None;
- editor.gutter_hover_button.0
} else {
editor.gutter_hover_button.1 = None;
None
};
- if &gutter_hover_button != &editor.gutter_hover_button.0 {
- editor.gutter_hover_button.0 = gutter_hover_button;
+ if &breakpoint_indicator != &editor.gutter_hover_button.0 {
+ editor.gutter_hover_button.0 = breakpoint_indicator;
cx.notify();
}
@@ -4732,10 +4728,7 @@ impl EditorElement {
let mut rows = Vec::::new();
for item in editor.sticky_headers.iter().flatten() {
- let start_point = item
- .source_range_for_text
- .start
- .to_point(snapshot.buffer_snapshot());
+ let start_point = item.range.start.to_point(snapshot.buffer_snapshot());
let end_point = item.range.end.to_point(snapshot.buffer_snapshot());
let sticky_row = snapshot
@@ -8355,34 +8348,21 @@ pub(crate) fn header_jump_data(
) -> JumpData {
let multibuffer_snapshot = editor_snapshot.buffer_snapshot();
let buffer = first_excerpt.buffer(multibuffer_snapshot);
- let (jump_anchor, jump_buffer, excerpt_start) = if let Some(anchor) =
+ let (jump_anchor, jump_buffer) = if let Some(anchor) =
latest_selection_anchors.get(&first_excerpt.buffer_id())
&& let Some((jump_anchor, selection_buffer)) =
multibuffer_snapshot.anchor_to_buffer_anchor(*anchor)
{
- let jump_offset = text::ToOffset::to_offset(&jump_anchor, selection_buffer);
- let selection_excerpt_start = multibuffer_snapshot
- .excerpts_for_buffer(jump_anchor.buffer_id)
- .find(|excerpt| {
- let start = text::ToOffset::to_offset(&excerpt.context.start, selection_buffer);
- let end = text::ToOffset::to_offset(&excerpt.context.end, selection_buffer);
- start <= jump_offset && jump_offset <= end
- })
- .map(|excerpt| excerpt.context.start)
- .unwrap_or(first_excerpt.range.context.start);
- (jump_anchor, selection_buffer, selection_excerpt_start)
+ (jump_anchor, selection_buffer)
} else {
- (
- first_excerpt.range.primary.start,
- buffer,
- first_excerpt.range.context.start,
- )
+ (first_excerpt.range.primary.start, buffer)
};
+ let excerpt_start = first_excerpt.range.context.start;
let jump_position = language::ToPoint::to_point(&jump_anchor, jump_buffer);
let rows_from_excerpt_start = if jump_anchor == excerpt_start {
0
} else {
- let excerpt_start_point = language::ToPoint::to_point(&excerpt_start, jump_buffer);
+ let excerpt_start_point = language::ToPoint::to_point(&excerpt_start, buffer);
jump_position.row.saturating_sub(excerpt_start_point.row)
};
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 125f09c9661..1752aefc5e6 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -1799,10 +1799,6 @@ impl SearchableItem for Editor {
});
}
}
-
- /// Takes the current cursor position and finds the next match in the
- /// provided `direction`, the provide `count` number of times, wrapping
- /// around if necessary.
fn match_index_for_direction(
&mut self,
matches: &[Range],
@@ -1813,48 +1809,45 @@ impl SearchableItem for Editor {
_: &mut Window,
cx: &mut Context,
) -> usize {
- if count == 0 {
- return current_index;
- }
-
- let cursor = if self.selections.disjoint_anchors_arc().len() == 1 {
+ let buffer = self.buffer().read(cx).snapshot(cx);
+ let current_index_position = if self.selections.disjoint_anchors_arc().len() == 1 {
self.selections.newest_anchor().head()
} else {
matches[current_index].start
};
- let buffer = self.buffer().read(cx).snapshot(cx);
- let new_idx = match direction {
- Direction::Next => matches
- .iter()
- .position(|m| m.start.cmp(&cursor, &buffer).is_gt())
- .unwrap_or(0),
- Direction::Prev => matches
- .iter()
- .rposition(|m| m.end.cmp(&cursor, &buffer).is_lt())
- .unwrap_or(matches.len() - 1),
- } as isize;
+ let mut count = count % matches.len();
+ if count == 0 {
+ return current_index;
+ }
+ match direction {
+ Direction::Next => {
+ if matches[current_index]
+ .start
+ .cmp(¤t_index_position, &buffer)
+ .is_gt()
+ {
+ count -= 1
+ }
- // We'll use `count - 1` because the first jump to the next or previous
- // match already happens in the scenario above, when we find the next or
- // previous match starting from the cursor position.
- let count = count.saturating_sub(1);
- let count = match direction {
- Direction::Prev => -(count as isize),
- Direction::Next => count as isize,
- };
+ (current_index + count) % matches.len()
+ }
+ Direction::Prev => {
+ if matches[current_index]
+ .end
+ .cmp(¤t_index_position, &buffer)
+ .is_lt()
+ {
+ count -= 1;
+ }
- let new_idx = (new_idx + count) % matches.len() as isize;
- let new_idx = if new_idx.is_negative() {
- // We need a `matches.len() - 1` here in case `next_idx` has now been
- // set to `0`, otherwise we'd end up returning `matches.len()`, which
- // would be out of bounds.
- new_idx + (matches.len() - 1) as isize
- } else {
- new_idx
- };
- assert!(new_idx < matches.len() as isize);
- new_idx as usize
+ if current_index >= count {
+ current_index - count
+ } else {
+ matches.len() - (count - current_index)
+ }
+ }
+ }
}
fn find_matches(
diff --git a/crates/editor/src/split.rs b/crates/editor/src/split.rs
index 347383d0171..43479f1713c 100644
--- a/crates/editor/src/split.rs
+++ b/crates/editor/src/split.rs
@@ -433,17 +433,6 @@ impl SplittableEditor {
self.lhs.as_ref().map(|s| &s.editor)
}
- pub fn update_editors(
- &self,
- cx: &mut Context,
- f: impl Fn(&mut Editor, &mut Context),
- ) {
- if let Some(lhs) = &self.lhs {
- lhs.editor.update(cx, &f);
- }
- self.rhs_editor.update(cx, &f);
- }
-
pub fn diff_view_style(&self) -> DiffViewStyle {
self.diff_view_style
}
@@ -457,18 +446,15 @@ impl SplittableEditor {
render_diff_hunk_controls: RenderDiffHunkControlsFn,
cx: &mut Context,
) {
- self.update_editors(cx, |editor, cx| {
+ self.rhs_editor.update(cx, |editor, cx| {
editor.set_render_diff_hunk_controls(render_diff_hunk_controls.clone(), cx);
});
- }
- pub fn disable_diff_hunk_controls(&self, cx: &mut Context) {
- let empty_controls = Arc::new(|_, _: &_, _, _, _, _: &_, _: &mut _, _: &mut _| {
- gpui::Empty.into_any_element()
- });
- self.update_editors(cx, |editor, cx| {
- editor.set_render_diff_hunk_controls(empty_controls.clone(), cx);
- });
+ if let Some(lhs) = &self.lhs {
+ lhs.editor.update(cx, |editor, cx| {
+ editor.set_render_diff_hunk_controls(render_diff_hunk_controls.clone(), cx);
+ });
+ }
}
fn focused_side(&self) -> SplitSide {
@@ -505,7 +491,6 @@ impl SplittableEditor {
editor.set_expand_all_diff_hunks(cx);
editor.disable_runnables();
editor.disable_inline_diagnostics();
- editor.disable_mouse_wheel_zoom();
editor.set_minimap_visibility(crate::MinimapVisibility::Disabled, window, cx);
editor.start_temporary_diff_override();
editor
@@ -601,7 +586,6 @@ impl SplittableEditor {
editor.disable_lsp_data();
editor.disable_runnables();
editor.disable_diagnostics(cx);
- editor.disable_mouse_wheel_zoom();
editor.set_minimap_visibility(crate::MinimapVisibility::Disabled, window, cx);
editor
});
@@ -2141,9 +2125,14 @@ mod tests {
window,
cx,
);
- editor.update_editors(cx, |editor, cx| {
+ editor.rhs_editor.update(cx, |editor, cx| {
editor.set_soft_wrap_mode(soft_wrap, cx);
});
+ if let Some(lhs) = &editor.lhs {
+ lhs.editor.update(cx, |editor, cx| {
+ editor.set_soft_wrap_mode(soft_wrap, cx);
+ });
+ }
editor
});
(editor, cx)
diff --git a/crates/file_finder/Cargo.toml b/crates/file_finder/Cargo.toml
index f7f09956c15..67ebab62295 100644
--- a/crates/file_finder/Cargo.toml
+++ b/crates/file_finder/Cargo.toml
@@ -31,7 +31,6 @@ settings.workspace = true
serde.workspace = true
theme.workspace = true
ui.workspace = true
-ui_input.workspace = true
util.workspace = true
workspace.workspace = true
zed_actions.workspace = true
diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index d75481f6f74..9a9cc983fa7 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -13,8 +13,8 @@ use fuzzy::{StringMatch, StringMatchCandidate};
use fuzzy_nucleo::{PathMatch, PathMatchCandidate};
use gpui::{
Action, AnyElement, App, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
- KeyContext, Modifiers, ModifiersChangedEvent, ParentElement, Render,
- StatefulInteractiveElement, Styled, Task, WeakEntity, Window, actions, rems,
+ KeyContext, Modifiers, ModifiersChangedEvent, ParentElement, Render, Styled, Task, WeakEntity,
+ Window, actions, rems,
};
use open_path_prompt::{
OpenPathPrompt,
@@ -37,10 +37,9 @@ use std::{
},
};
use ui::{
- ButtonLike, CommonAnimationExt, ContextMenu, HighlightedLabel, Indicator, KeyBinding, ListItem,
- ListItemSpacing, PopoverMenu, PopoverMenuHandle, TintColor, Tooltip, prelude::*,
+ ButtonLike, ContextMenu, HighlightedLabel, Indicator, KeyBinding, ListItem, ListItemSpacing,
+ PopoverMenu, PopoverMenuHandle, TintColor, Tooltip, prelude::*,
};
-use ui_input::ErasedEditor;
use util::{
ResultExt, maybe,
paths::{PathStyle, PathWithPosition},
@@ -1758,41 +1757,6 @@ impl PickerDelegate for FileFinderDelegate {
)
}
- fn render_editor(
- &self,
- editor: &Arc,
- window: &mut Window,
- cx: &mut Context>,
- ) -> Div {
- let has_search_query = self.latest_search_query.is_some();
- let is_project_scan_running = {
- let worktree_store = self.project.read(cx).worktree_store();
- !worktree_store.read(cx).initial_scan_completed()
- };
-
- h_flex()
- .flex_none()
- .h_9()
- .px_2p5()
- .justify_between()
- .border_b_1()
- .border_color(cx.theme().colors().border_variant)
- .child(editor.render(window, cx))
- .when(is_project_scan_running && has_search_query, |this| {
- this.child(
- h_flex()
- .id("project-scan-indicator")
- .tooltip(Tooltip::text("Project Scan in Progress…"))
- .child(
- Icon::new(IconName::LoadCircle)
- .color(Color::Accent)
- .size(IconSize::Small)
- .with_rotate_animation(2),
- ),
- )
- })
- }
-
fn render_footer(&self, _: &mut Window, cx: &mut Context>) -> Option {
let focus_handle = self.focus_handle.clone();
diff --git a/crates/fs/Cargo.toml b/crates/fs/Cargo.toml
index eefe2717f22..e7b8dcd4ebd 100644
--- a/crates/fs/Cargo.toml
+++ b/crates/fs/Cargo.toml
@@ -36,7 +36,6 @@ thiserror.workspace = true
serde.workspace = true
serde_json.workspace = true
smol.workspace = true
-telemetry.workspace = true
tempfile.workspace = true
text.workspace = true
time.workspace = true
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index 6b7e4816a18..6694b19e373 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -72,133 +72,6 @@ pub trait Watcher: Send + Sync {
fn remove(&self, path: &Path) -> Result<()>;
}
-/// Detect whether a path requires polling instead of native file watching.
-///
-/// Returns `true` for filesystem types where inotify/FSEvents/ReadDirectoryChanges
-/// silently fail to deliver events: 9P (WSL drvfs), NFS, CIFS/SMB, FUSE (sshfs), etc.
-///
-/// Can be overridden with the `ZED_FILE_WATCHER_MODE` environment variable:
-/// - `native` — always use native OS watcher
-/// - `poll` — always use polling
-/// - `auto` (default) — auto-detect based on filesystem type
-pub fn requires_poll_watcher(path: &Path) -> bool {
- match std::env::var("ZED_FILE_WATCHER_MODE")
- .as_deref()
- .unwrap_or("auto")
- {
- "native" => return false,
- "poll" => return true,
- _ => {}
- }
-
- #[cfg(target_os = "linux")]
- {
- let path = effective_watch_path(path);
- return detect_requires_poll_watcher_linux(&path);
- }
-
- #[cfg(not(target_os = "linux"))]
- {
- let _ = path;
- false
- }
-}
-
-pub fn effective_watch_path(path: &Path) -> PathBuf {
- if path.exists() {
- return path.to_path_buf();
- }
-
- for ancestor in path.ancestors() {
- if ancestor.exists() {
- return ancestor.to_path_buf();
- }
- }
-
- path.to_path_buf()
-}
-
-#[cfg(target_os = "linux")]
-fn detect_requires_poll_watcher_linux(path: &Path) -> bool {
- use std::ffi::CString;
- use std::os::unix::ffi::OsStrExt;
-
- // Check filesystem type via statfs
- let c_path = match CString::new(path.as_os_str().as_bytes()) {
- Ok(p) => p,
- Err(_) => return false,
- };
-
- let mut stat: libc::statfs = unsafe { std::mem::zeroed() };
- if unsafe { libc::statfs(c_path.as_ptr(), &mut stat) } != 0 {
- return false;
- }
-
- // Filesystem magic numbers where inotify does not deliver events.
- // These are defined in linux/magic.h and statfs(2).
- const V9FS_MAGIC: i64 = 0x01021997; // Plan 9 / WSL2 interop (drvfs)
- const NFS_SUPER_MAGIC: i64 = 0x6969;
- const CIFS_MAGIC: i64 = 0xFF534D42u32 as i64; // CIFS/SMB
- const SMB_SUPER_MAGIC: i64 = 0x517B;
- const SMB2_MAGIC: i64 = 0xFE534D42u32 as i64;
- const FUSE_SUPER_MAGIC: i64 = 0x65735546; // FUSE (includes sshfs)
-
- let fs_type = stat.f_type;
- if fs_type == V9FS_MAGIC
- || fs_type == NFS_SUPER_MAGIC
- || fs_type == CIFS_MAGIC
- || fs_type == SMB_SUPER_MAGIC
- || fs_type == SMB2_MAGIC
- || fs_type == FUSE_SUPER_MAGIC
- {
- log::info!(
- "Detected network/virtual filesystem (type 0x{:x}) at {}, using poll watcher",
- fs_type,
- path.display()
- );
- return true;
- }
-
- // Also check for WSL + /mnt// pattern as a fallback
- // in case statfs returns an unexpected type for drvfs
- if is_wsl_drvfs_path(path) {
- log::info!(
- "Detected WSL drvfs mount at {}, using poll watcher",
- path.display()
- );
- return true;
- }
-
- false
-}
-
-#[cfg(target_os = "linux")]
-fn is_wsl_drvfs_path(path: &Path) -> bool {
- // Only relevant inside WSL
- if std::env::var_os("WSL_DISTRO_NAME").is_none() {
- if let Ok(version) = std::fs::read_to_string("/proc/version") {
- let v = version.to_lowercase();
- if !v.contains("microsoft") && !v.contains("wsl") {
- return false;
- }
- } else {
- return false;
- }
- }
-
- // Windows drives are mounted at /mnt/c, /mnt/d, etc.
- let path_str = match path.to_str() {
- Some(s) => s,
- None => return false,
- };
- if !path_str.starts_with("/mnt/") || path_str.len() < 6 {
- return false;
- }
- let after_mnt = &path_str[5..];
- after_mnt.starts_with(|c: char| c.is_ascii_alphabetic())
- && (after_mnt.len() == 1 || after_mnt.as_bytes()[1] == b'/')
-}
-
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub enum PathEventKind {
Removed,
@@ -1197,34 +1070,19 @@ impl Fs for RealFs {
use util::{ResultExt as _, paths::SanitizedPath};
let executor = self.executor.clone();
- let use_poll = requires_poll_watcher(path);
- let watch_path = effective_watch_path(path);
-
let (tx, rx) = smol::channel::unbounded();
let pending_paths: Arc>> = Default::default();
+ let watcher = Arc::new(fs_watcher::FsWatcher::new(tx, pending_paths.clone()));
- let mode = if use_poll {
- log::info!(
- "Using poll watcher ({}ms interval) for {}",
- fs_watcher::poll_interval().as_millis(),
- path.display()
- );
- telemetry::event!("fs_watcher_poll", path = path.display().to_string());
- fs_watcher::WatcherMode::Poll
- } else {
- fs_watcher::WatcherMode::Native
- };
- let watcher: Arc = Arc::new(fs_watcher::FsWatcher::new(
- tx.clone(),
- pending_paths.clone(),
- mode,
- ));
-
- if let Err(e) = watcher.add(&watch_path) {
+ // If the path doesn't exist yet (e.g. settings.json), watch the parent dir to learn when it's created.
+ if let Err(e) = watcher.add(path)
+ && let Some(parent) = path.parent()
+ && let Err(parent_e) = watcher.add(parent)
+ {
log::warn!(
- "Failed to watch {} using {}:\n{e}",
+ "Failed to watch {} and its parent directory {}:\n{e}\n{parent_e}",
path.display(),
- watch_path.display()
+ parent.display()
);
}
diff --git a/crates/fs/src/fs_watcher.rs b/crates/fs/src/fs_watcher.rs
index 909424558b7..02a6b087811 100644
--- a/crates/fs/src/fs_watcher.rs
+++ b/crates/fs/src/fs_watcher.rs
@@ -4,38 +4,27 @@ use std::{
collections::{BTreeMap, HashMap},
ops::DerefMut,
path::Path,
- sync::{Arc, LazyLock, OnceLock},
- time::Duration,
+ sync::{Arc, OnceLock},
};
use util::{ResultExt, paths::SanitizedPath};
use crate::{PathEvent, PathEventKind, Watcher};
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
-pub enum WatcherMode {
- #[default]
- Native,
- Poll,
-}
-
pub struct FsWatcher {
tx: smol::channel::Sender<()>,
pending_path_events: Arc>>,
registrations: Mutex, WatcherRegistrationId>>,
- mode: WatcherMode,
}
impl FsWatcher {
pub fn new(
tx: smol::channel::Sender<()>,
pending_path_events: Arc>>,
- mode: WatcherMode,
) -> Self {
Self {
tx,
pending_path_events,
registrations: Default::default(),
- mode,
}
}
}
@@ -48,10 +37,11 @@ impl Drop for FsWatcher {
std::mem::swap(old.deref_mut(), &mut registrations);
}
- let global_watcher = global_watcher();
- for (_, registration) in registrations {
- global_watcher.remove(registration);
- }
+ let _ = global(|g| {
+ for (_, registration) in registrations {
+ g.remove(registration);
+ }
+ });
}
}
@@ -59,10 +49,13 @@ impl Watcher for FsWatcher {
fn add(&self, path: &std::path::Path) -> anyhow::Result<()> {
log::trace!("watcher add: {path:?}");
let tx = self.tx.clone();
- let pending_path_events = self.pending_path_events.clone();
+ let pending_paths = self.pending_path_events.clone();
- if (self.mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))
- && let Some((watched_path, _)) = self
+ #[cfg(any(target_os = "windows", target_os = "macos"))]
+ {
+ // Return early if an ancestor of this path was already being watched.
+ // saves a huge amount of memory
+ if let Some((watched_path, _)) = self
.registrations
.lock()
.range::((
@@ -70,36 +63,86 @@ impl Watcher for FsWatcher {
std::ops::Bound::Included(path),
))
.next_back()
- && path.starts_with(watched_path.as_ref())
- {
- log::trace!(
- "path to watch is covered by existing registration: {path:?}, {watched_path:?}"
- );
- return Ok(());
+ && path.starts_with(watched_path.as_ref())
+ {
+ log::trace!(
+ "path to watch is covered by existing registration: {path:?}, {watched_path:?}"
+ );
+ return Ok(());
+ }
}
-
- if self.registrations.lock().contains_key(path) {
- log::trace!("path to watch is already watched: {path:?}");
- return Ok(());
+ #[cfg(target_os = "linux")]
+ {
+ if self.registrations.lock().contains_key(path) {
+ log::trace!("path to watch is already watched: {path:?}");
+ return Ok(());
+ }
}
let root_path = SanitizedPath::new_arc(path);
let path: Arc = path.into();
+ #[cfg(any(target_os = "windows", target_os = "macos"))]
+ let mode = notify::RecursiveMode::Recursive;
+ #[cfg(target_os = "linux")]
+ let mode = notify::RecursiveMode::NonRecursive;
+
let registration_path = path.clone();
- let registration_id = global_watcher().add(
- path.clone(),
- self.mode,
- move |result: Result<¬ify::Event, ¬ify::Error>| match result {
- Ok(event) => {
+ let registration_id = global({
+ let watch_path = path.clone();
+ let callback_path = path;
+ |g| {
+ g.add(watch_path, mode, move |event: ¬ify::Event| {
log::trace!("watcher received event: {event:?}");
- push_notify_event(&tx, &pending_path_events, &root_path, path.as_ref(), event);
- }
- Err(error) => {
- push_notify_error(&tx, &pending_path_events, path.as_ref(), error);
- }
- },
- )?;
+ let kind = match event.kind {
+ EventKind::Create(_) => Some(PathEventKind::Created),
+ EventKind::Modify(_) => Some(PathEventKind::Changed),
+ EventKind::Remove(_) => Some(PathEventKind::Removed),
+ _ => None,
+ };
+ let mut path_events = event
+ .paths
+ .iter()
+ .filter_map(|event_path| {
+ let event_path = SanitizedPath::new(event_path);
+ event_path.starts_with(&root_path).then(|| PathEvent {
+ path: event_path.as_path().to_path_buf(),
+ kind,
+ })
+ })
+ .collect::>();
+
+ let is_rescan_event = event.need_rescan();
+ if is_rescan_event {
+ log::warn!(
+ "filesystem watcher lost sync for {callback_path:?}; scheduling rescan"
+ );
+ // we only keep the first event per path below, this ensures it will be the rescan event
+ // we'll remove any existing pending events for the same reason once we have the lock below
+ path_events.retain(|p| &p.path != callback_path.as_ref());
+ path_events.push(PathEvent {
+ path: callback_path.to_path_buf(),
+ kind: Some(PathEventKind::Rescan),
+ });
+ }
+
+ if !path_events.is_empty() {
+ path_events.sort();
+ let mut pending_paths = pending_paths.lock();
+ if pending_paths.is_empty() {
+ tx.try_send(()).ok();
+ }
+ coalesce_pending_rescans(&mut pending_paths, &mut path_events);
+ util::extend_sorted(
+ &mut *pending_paths,
+ path_events,
+ usize::MAX,
+ |a, b| a.path.cmp(&b.path),
+ );
+ }
+ })
+ }
+ })??;
self.registrations
.lock()
@@ -114,85 +157,10 @@ impl Watcher for FsWatcher {
return Ok(());
};
- global_watcher().remove(registration);
- Ok(())
+ global(|w| w.remove(registration))
}
}
-fn enqueue_path_events(
- tx: &smol::channel::Sender<()>,
- pending_path_events: &Arc>>,
- mut path_events: Vec,
-) {
- if path_events.is_empty() {
- return;
- }
-
- path_events.sort();
- let mut pending_paths = pending_path_events.lock();
- if pending_paths.is_empty() {
- tx.try_send(()).ok();
- }
- coalesce_pending_rescans(&mut pending_paths, &mut path_events);
- util::extend_sorted(&mut *pending_paths, path_events, usize::MAX, |a, b| {
- a.path.cmp(&b.path)
- });
-}
-
-fn push_notify_event(
- tx: &smol::channel::Sender<()>,
- pending_path_events: &Arc>>,
- root_path: &SanitizedPath,
- watched_root: &Path,
- event: ¬ify::Event,
-) {
- let kind = match event.kind {
- EventKind::Create(_) => Some(PathEventKind::Created),
- EventKind::Modify(_) => Some(PathEventKind::Changed),
- EventKind::Remove(_) => Some(PathEventKind::Removed),
- _ => None,
- };
- let mut path_events = event
- .paths
- .iter()
- .filter_map(|event_path| {
- let event_path = SanitizedPath::new(event_path);
- event_path.starts_with(root_path).then(|| PathEvent {
- path: event_path.as_path().to_path_buf(),
- kind,
- })
- })
- .collect::>();
-
- if event.need_rescan() {
- log::warn!("filesystem watcher lost sync for {watched_root:?}; scheduling rescan");
- path_events.retain(|path_event| path_event.path != watched_root);
- path_events.push(PathEvent {
- path: watched_root.to_path_buf(),
- kind: Some(PathEventKind::Rescan),
- });
- }
-
- enqueue_path_events(tx, pending_path_events, path_events);
-}
-
-fn push_notify_error(
- tx: &smol::channel::Sender<()>,
- pending_path_events: &Arc>>,
- watched_root: &Path,
- error: ¬ify::Error,
-) {
- log::warn!("watcher error for {watched_root:?}: {error}");
- enqueue_path_events(
- tx,
- pending_path_events,
- vec![PathEvent {
- path: watched_root.to_path_buf(),
- kind: Some(PathEventKind::Rescan),
- }],
- );
-}
-
fn coalesce_pending_rescans(pending_paths: &mut Vec, path_events: &mut Vec) {
if !path_events
.iter()
@@ -247,34 +215,29 @@ fn is_covered_rescan(kind: Option, path: &Path, ancestor: &Path)
pub struct WatcherRegistrationId(u32);
struct WatcherRegistrationState {
- callback: Arc Fn(Result<&'a notify::Event, &'a notify::Error>) + Send + Sync>,
+ callback: Arc,
path: Arc,
- mode: WatcherMode,
}
struct WatcherState {
watchers: HashMap,
- native_path_registrations: HashMap, u32>,
- poll_path_registrations: HashMap, u32>,
+ path_registrations: HashMap, u32>,
last_registration: WatcherRegistrationId,
}
-impl WatcherState {
- fn path_registrations(&mut self, mode: WatcherMode) -> &mut HashMap, u32> {
- match mode {
- WatcherMode::Native => &mut self.native_path_registrations,
- WatcherMode::Poll => &mut self.poll_path_registrations,
- }
- }
-}
-
pub struct GlobalWatcher {
state: Mutex,
- // DANGER: never keep state lock while holding watcher lock
- // two mutexes because calling watcher.add triggers watcher.event, which needs watchers.
- native_watcher: Mutex>,
- poll_watcher: Mutex>,
+ // DANGER: never keep the state lock while holding the watcher lock
+ // two mutexes because calling watcher.add triggers an watcher.event, which needs watchers.
+ #[cfg(target_os = "linux")]
+ watcher: Mutex,
+ #[cfg(target_os = "freebsd")]
+ watcher: Mutex,
+ #[cfg(target_os = "windows")]
+ watcher: Mutex,
+ #[cfg(target_os = "macos")]
+ watcher: Mutex,
}
impl GlobalWatcher {
@@ -282,17 +245,27 @@ impl GlobalWatcher {
fn add(
&self,
path: Arc,
- mode: WatcherMode,
- cb: impl for<'a> Fn(Result<&'a notify::Event, &'a notify::Error>) + Send + Sync + 'static,
+ mode: notify::RecursiveMode,
+ cb: impl Fn(¬ify::Event) + Send + Sync + 'static,
) -> anyhow::Result {
- let mut state = self.state.lock();
- let registrations_for_mode = state.path_registrations(mode);
- let path_already_covered =
- path_already_covered(path.as_ref(), registrations_for_mode, mode);
+ use notify::Watcher;
- if !path_already_covered && !registrations_for_mode.contains_key(&path) {
+ let mut state = self.state.lock();
+
+ // Check if this path is already covered by an existing watched ancestor path.
+ // On macOS and Windows, watching is recursive, so we don't need to watch
+ // child paths if an ancestor is already being watched.
+ #[cfg(any(target_os = "windows", target_os = "macos"))]
+ let path_already_covered = state.path_registrations.keys().any(|existing| {
+ path.starts_with(existing.as_ref()) && path.as_ref() != existing.as_ref()
+ });
+
+ #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+ let path_already_covered = false;
+
+ if !path_already_covered && !state.path_registrations.contains_key(&path) {
drop(state);
- self.watch(&path, mode)?;
+ self.watcher.lock().watch(&path, mode)?;
state = self.state.lock();
}
@@ -302,191 +275,39 @@ impl GlobalWatcher {
let registration_state = WatcherRegistrationState {
callback: Arc::new(cb),
path: path.clone(),
- mode,
};
state.watchers.insert(id, registration_state);
- *state.path_registrations(mode).entry(path).or_insert(0) += 1;
+ *state.path_registrations.entry(path).or_insert(0) += 1;
Ok(id)
}
pub fn remove(&self, id: WatcherRegistrationId) {
+ use notify::Watcher;
let mut state = self.state.lock();
let Some(registration_state) = state.watchers.remove(&id) else {
return;
};
- let path_registrations = state.path_registrations(registration_state.mode);
- let Some(count) = path_registrations.get_mut(®istration_state.path) else {
+ let Some(count) = state.path_registrations.get_mut(®istration_state.path) else {
return;
};
*count -= 1;
if *count == 0 {
- path_registrations.remove(®istration_state.path);
- let path_still_covered = path_already_covered(
- registration_state.path.as_ref(),
- path_registrations,
- registration_state.mode,
- );
+ state.path_registrations.remove(®istration_state.path);
- if !path_still_covered {
- drop(state);
- self.unwatch(®istration_state.path, registration_state.mode)
- .log_err();
- }
- }
- }
-
- fn watch(&self, path: &Path, mode: WatcherMode) -> anyhow::Result<()> {
- use notify::Watcher;
-
- match mode {
- WatcherMode::Native => {
- self.ensure_native_watcher()?;
- self.native_watcher
- .lock()
- .as_mut()
- .expect("native watcher initialized")
- .watch(
- path,
- if cfg!(any(target_os = "windows", target_os = "macos")) {
- notify::RecursiveMode::Recursive
- } else {
- notify::RecursiveMode::NonRecursive
- },
- )?;
- }
- WatcherMode::Poll => {
- self.ensure_poll_watcher()?;
- self.poll_watcher
- .lock()
- .as_mut()
- .expect("poll watcher initialized")
- .watch(path, notify::RecursiveMode::Recursive)?;
- }
- }
-
- Ok(())
- }
-
- fn unwatch(&self, path: &Path, mode: WatcherMode) -> anyhow::Result<()> {
- use notify::Watcher;
-
- match mode {
- WatcherMode::Native => {
- if let Some(watcher) = self.native_watcher.lock().as_mut() {
- watcher.unwatch(path)?;
- }
- }
- WatcherMode::Poll => {
- if let Some(watcher) = self.poll_watcher.lock().as_mut() {
- watcher.unwatch(path)?;
- }
- }
- }
-
- Ok(())
- }
-
- fn ensure_native_watcher(&self) -> anyhow::Result<()> {
- if self.native_watcher.lock().is_some() {
- return Ok(());
- }
-
- let watcher = notify::recommended_watcher(handle_native_event)?;
- *self.native_watcher.lock() = Some(watcher);
- Ok(())
- }
-
- fn ensure_poll_watcher(&self) -> anyhow::Result<()> {
- if self.poll_watcher.lock().is_some() {
- return Ok(());
- }
-
- let config = notify::Config::default().with_poll_interval(*POLL_INTERVAL);
- let watcher = notify::PollWatcher::new(handle_poll_event, config)?;
- *self.poll_watcher.lock() = Some(watcher);
- Ok(())
- }
-}
-
-fn path_already_covered(
- path: &Path,
- path_registrations: &HashMap, u32>,
- mode: WatcherMode,
-) -> bool {
- (mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))
- && path_registrations
- .keys()
- .any(|existing| path.starts_with(existing.as_ref()) && path != existing.as_ref())
-}
-
-static POLL_INTERVAL: LazyLock = LazyLock::new(|| {
- let poll_ms: u64 = std::env::var("ZED_FILE_WATCHER_POLL_MS")
- .ok()
- .and_then(|value| value.parse().ok())
- .unwrap_or(2000)
- .clamp(500, 30000);
- Duration::from_millis(poll_ms)
-});
-
-pub fn poll_interval() -> Duration {
- *POLL_INTERVAL
-}
-
-static FS_WATCHER_INSTANCE: OnceLock = OnceLock::new();
-
-fn global_watcher() -> &'static GlobalWatcher {
- FS_WATCHER_INSTANCE.get_or_init(|| GlobalWatcher {
- state: Mutex::new(WatcherState {
- watchers: Default::default(),
- native_path_registrations: Default::default(),
- poll_path_registrations: Default::default(),
- last_registration: Default::default(),
- }),
- native_watcher: Mutex::new(None),
- poll_watcher: Mutex::new(None),
- })
-}
-
-fn handle_native_event(event: Result) {
- handle_event(WatcherMode::Native, event);
-}
-
-fn handle_poll_event(event: Result) {
- handle_event(WatcherMode::Poll, event);
-}
-
-fn handle_event(mode: WatcherMode, event: Result) {
- log::trace!("global handle event for {mode:?}: {event:?}");
-
- let callbacks = {
- let state = global_watcher().state.lock();
- state
- .watchers
- .values()
- .filter(|registration| registration.mode == mode)
- .map(|registration| registration.callback.clone())
- .collect::>()
- };
-
- match event {
- Ok(event) => {
- if matches!(event.kind, EventKind::Access(_)) {
- return;
- }
- for callback in callbacks {
- callback(Ok(&event));
- }
- }
- Err(error) => {
- for callback in callbacks {
- callback(Err(&error));
- }
+ drop(state);
+ self.watcher
+ .lock()
+ .unwatch(®istration_state.path)
+ .log_err();
}
}
}
+static FS_WATCHER_INSTANCE: OnceLock> =
+ OnceLock::new();
+
#[cfg(test)]
mod tests {
use super::*;
@@ -578,8 +399,45 @@ mod tests {
}
}
-pub fn global(f: impl FnOnce(&GlobalWatcher) -> T) -> anyhow::Result {
- let global_watcher = global_watcher();
- global_watcher.ensure_native_watcher()?;
- Ok(f(global_watcher))
+fn handle_event(event: Result) {
+ log::trace!("global handle event: {event:?}");
+ // Filter out access events, which could lead to a weird bug on Linux after upgrading notify
+ // https://github.com/zed-industries/zed/actions/runs/14085230504/job/39449448832
+ let Some(event) = event
+ .log_err()
+ .filter(|event| !matches!(event.kind, EventKind::Access(_)))
+ else {
+ return;
+ };
+ global::<()>(move |watcher| {
+ let callbacks = {
+ let state = watcher.state.lock();
+ state
+ .watchers
+ .values()
+ .map(|r| r.callback.clone())
+ .collect::>()
+ };
+ for callback in callbacks {
+ callback(&event);
+ }
+ })
+ .log_err();
+}
+
+pub fn global(f: impl FnOnce(&GlobalWatcher) -> T) -> anyhow::Result {
+ let result = FS_WATCHER_INSTANCE.get_or_init(|| {
+ notify::recommended_watcher(handle_event).map(|file_watcher| GlobalWatcher {
+ state: Mutex::new(WatcherState {
+ watchers: Default::default(),
+ path_registrations: Default::default(),
+ last_registration: Default::default(),
+ }),
+ watcher: Mutex::new(file_watcher),
+ })
+ });
+ match result {
+ Ok(g) => Ok(f(g)),
+ Err(e) => Err(anyhow::anyhow!("{e}")),
+ }
}
diff --git a/crates/git_ui/Cargo.toml b/crates/git_ui/Cargo.toml
index 1e2d7f79dd3..5a9350f8aec 100644
--- a/crates/git_ui/Cargo.toml
+++ b/crates/git_ui/Cargo.toml
@@ -83,7 +83,6 @@ pretty_assertions.workspace = true
project = { workspace = true, features = ["test-support"] }
rand.workspace = true
settings = { workspace = true, features = ["test-support"] }
-task.workspace = true
unindent.workspace = true
workspace = { workspace = true, features = ["test-support"] }
zlog.workspace = true
diff --git a/crates/git_ui/src/branch_picker.rs b/crates/git_ui/src/branch_picker.rs
index b119d243ad6..69829231619 100644
--- a/crates/git_ui/src/branch_picker.rs
+++ b/crates/git_ui/src/branch_picker.rs
@@ -627,6 +627,9 @@ impl PickerDelegate for BranchListDelegate {
let focus_handle = self.focus_handle.clone();
let editor = editor.as_any().downcast_ref::>().unwrap();
+ let show_inline_filter =
+ self.editor_position() == PickerEditorPosition::End || !self.show_footer;
+
v_flex()
.when(
self.editor_position() == PickerEditorPosition::End,
@@ -639,34 +642,32 @@ impl PickerDelegate for BranchListDelegate {
.h_9()
.px_2p5()
.child(editor.clone())
- .when(
- self.editor_position() == PickerEditorPosition::End,
- |this| {
- let tooltip_label = match self.branch_filter {
- BranchFilter::All => "Filter Remote Branches",
- BranchFilter::Remote => "Show All Branches",
- };
+ .when(show_inline_filter, |this| {
+ let tooltip_label = match self.branch_filter {
+ BranchFilter::All => "Filter Remote Branches",
+ BranchFilter::Remote => "Show All Branches",
+ };
- this.gap_1().justify_between().child({
- IconButton::new("filter-remotes", IconName::Filter)
- .toggle_state(self.branch_filter == BranchFilter::Remote)
- .tooltip(move |_, cx| {
- Tooltip::for_action_in(
- tooltip_label,
- &branch_picker::FilterRemotes,
- &focus_handle,
- cx,
- )
- })
- .on_click(|_click, window, cx| {
- window.dispatch_action(
- branch_picker::FilterRemotes.boxed_clone(),
- cx,
- );
- })
- })
- },
- ),
+ this.gap_1().justify_between().child({
+ IconButton::new("filter-remotes", IconName::Filter)
+ .toggle_state(self.branch_filter == BranchFilter::Remote)
+ .icon_size(IconSize::Small)
+ .tooltip(move |_, cx| {
+ Tooltip::for_action_in(
+ tooltip_label,
+ &branch_picker::FilterRemotes,
+ &focus_handle,
+ cx,
+ )
+ })
+ .on_click(|_click, window, cx| {
+ window.dispatch_action(
+ branch_picker::FilterRemotes.boxed_clone(),
+ cx,
+ );
+ })
+ })
+ }),
)
.when(
self.editor_position() == PickerEditorPosition::Start,
diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs
index 921bcd19608..ad6d960a307 100644
--- a/crates/git_ui/src/commit_modal.rs
+++ b/crates/git_ui/src/commit_modal.rs
@@ -1,6 +1,5 @@
use crate::branch_picker::{self, BranchList};
use crate::git_panel::{GitPanel, commit_message_editor, panel_editor_style};
-use crate::git_panel_settings::GitPanelSettings;
use git::repository::CommitOptions;
use git::{Amend, Commit, GenerateCommitMessage, Signoff};
use panel::panel_button;
@@ -540,18 +539,6 @@ impl Render for CommitModal {
let border_radius = properties.modal_border_radius;
let editor_focus_handle = self.commit_editor.focus_handle(cx);
- let max_title_length = GitPanelSettings::get_global(cx).commit_title_max_length;
- let title_exceeds_limit = if max_title_length > 0 {
- self.commit_editor
- .read(cx)
- .text(cx)
- .lines()
- .next()
- .is_some_and(|title| title.len() > max_title_length)
- } else {
- false
- };
-
v_flex()
.id("commit-modal")
.key_context("GitCommit")
@@ -580,9 +567,6 @@ impl Render for CommitModal {
this.toggle_branch_selector(window, cx);
}),
)
- .w(width)
- .h_112()
- .p(container_padding)
.elevation_3(cx)
.overflow_hidden()
.flex_none()
@@ -591,50 +575,30 @@ impl Render for CommitModal {
.rounded(px(border_radius))
.border_1()
.border_color(cx.theme().colors().border)
+ .w(width)
+ .p(container_padding)
.child(
v_flex()
.id("editor-container")
- .cursor_text()
+ .justify_between()
.p_2()
.size_full()
.gap_2()
- .justify_between()
.rounded(properties.editor_border_radius())
.overflow_hidden()
+ .cursor_text()
.bg(cx.theme().colors().editor_background)
.border_1()
- .border_color(if title_exceeds_limit {
- cx.theme().status().warning_border
- } else {
- cx.theme().colors().border_variant
- })
+ .border_color(cx.theme().colors().border_variant)
.on_click(cx.listener(move |_, _: &ClickEvent, window, cx| {
window.focus(&editor_focus_handle, cx);
}))
- .child(self.render_commit_editor(window, cx))
- .when(title_exceeds_limit, |this| {
- this.child(
- h_flex()
- .absolute()
- .bottom_12()
- .w_full()
- .py_1()
- .px_2()
- .gap_1()
- .justify_center()
- .child(
- Icon::new(IconName::Warning)
- .size(IconSize::XSmall)
- .color(Color::Warning),
- )
- .child(
- Label::new(format!(
- "Commit message title exceeds {max_title_length}-character limit."
- ))
- .size(LabelSize::Small),
- ),
- )
- })
+ .child(
+ div()
+ .flex_1()
+ .size_full()
+ .child(self.render_commit_editor(window, cx)),
+ )
.child(self.render_footer(window, cx)),
)
}
diff --git a/crates/git_ui/src/file_diff_view.rs b/crates/git_ui/src/file_diff_view.rs
index e313700dd86..6fe3d9484b4 100644
--- a/crates/git_ui/src/file_diff_view.rs
+++ b/crates/git_ui/src/file_diff_view.rs
@@ -2,7 +2,7 @@
use anyhow::Result;
use buffer_diff::BufferDiff;
-use editor::{Editor, EditorEvent, EditorSettings, MultiBuffer, SplittableEditor};
+use editor::{Editor, EditorEvent, MultiBuffer};
use futures::{FutureExt, select_biased};
use gpui::{
AnyElement, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle,
@@ -10,7 +10,6 @@ use gpui::{
};
use language::{Buffer, HighlightedText, LanguageRegistry};
use project::Project;
-use settings::Settings;
use std::{
any::{Any, TypeId},
path::PathBuf,
@@ -27,7 +26,7 @@ use workspace::{
};
pub struct FileDiffView {
- editor: Entity,
+ editor: Entity,
old_buffer: Entity,
new_buffer: Entity,
buffer_changes_tx: watch::Sender<()>,
@@ -58,14 +57,12 @@ impl FileDiffView {
let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, languages, cx).await?;
workspace.update_in(cx, |workspace, window, cx| {
- let workspace_entity = cx.entity();
let diff_view = cx.new(|cx| {
FileDiffView::new(
old_buffer,
new_buffer,
buffer_diff,
project.clone(),
- workspace_entity,
window,
cx,
)
@@ -86,7 +83,6 @@ impl FileDiffView {
new_buffer: Entity,
diff: Entity,
project: Entity,
- workspace: Entity,
window: &mut Window,
cx: &mut Context,
) -> Self {
@@ -96,19 +92,16 @@ impl FileDiffView {
multibuffer
});
let editor = cx.new(|cx| {
- let splittable = SplittableEditor::new(
- EditorSettings::get_global(cx).diff_view_style,
- multibuffer.clone(),
- project.clone(),
- workspace,
- window,
+ let mut editor =
+ Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
+ editor.start_temporary_diff_override();
+ editor.disable_diagnostics(cx);
+ editor.set_expand_all_diff_hunks(cx);
+ editor.set_render_diff_hunk_controls(
+ Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()),
cx,
);
- splittable.rhs_editor().update(cx, |editor, _| {
- editor.start_temporary_diff_override();
- });
- splittable.disable_diff_hunk_controls(cx);
- splittable
+ editor
});
let (buffer_changes_tx, mut buffer_changes_rx) = watch::channel(());
@@ -275,19 +268,22 @@ impl Item for FileDiffView {
}
fn deactivated(&mut self, window: &mut Window, cx: &mut Context) {
- self.editor.deactivated(window, cx);
+ self.editor
+ .update(cx, |editor, cx| editor.deactivated(window, cx));
}
fn act_as_type<'a>(
&'a self,
type_id: TypeId,
self_handle: &'a Entity,
- cx: &'a App,
+ _: &'a App,
) -> Option {
if type_id == TypeId::of::() {
Some(self_handle.clone().into())
+ } else if type_id == TypeId::of::() {
+ Some(self.editor.clone().into())
} else {
- self.editor.act_as_type(type_id, cx)
+ None
}
}
@@ -309,10 +305,8 @@ impl Item for FileDiffView {
_: &mut Window,
cx: &mut Context,
) {
- self.editor.update(cx, |editor, cx| {
- editor.rhs_editor().update(cx, |editor, _| {
- editor.set_nav_history(Some(nav_history));
- })
+ self.editor.update(cx, |editor, _| {
+ editor.set_nav_history(Some(nav_history));
});
}
@@ -322,11 +316,8 @@ impl Item for FileDiffView {
window: &mut Window,
cx: &mut Context,
) -> bool {
- self.editor.update(cx, |editor, cx| {
- editor
- .rhs_editor()
- .update(cx, |editor, cx| editor.navigate(data, window, cx))
- })
+ self.editor
+ .update(cx, |editor, cx| editor.navigate(data, window, cx))
}
fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
@@ -344,14 +335,13 @@ impl Item for FileDiffView {
cx: &mut Context,
) {
self.editor.update(cx, |editor, cx| {
- editor.rhs_editor().update(cx, |editor, cx| {
- editor.added_to_workspace(workspace, window, cx)
- })
+ editor.added_to_workspace(workspace, window, cx)
});
}
fn can_save(&self, cx: &App) -> bool {
- self.editor.read(cx).rhs_editor().read(cx).can_save(cx)
+ // The editor handles the new buffer, so delegate to it
+ self.editor.read(cx).can_save(cx)
}
fn save(
@@ -361,7 +351,9 @@ impl Item for FileDiffView {
window: &mut Window,
cx: &mut Context,
) -> Task> {
- self.editor.save(options, project, window, cx)
+ // Delegate saving to the editor, which manages the new buffer
+ self.editor
+ .update(cx, |editor, cx| editor.save(options, project, window, cx))
}
}
@@ -375,10 +367,9 @@ impl Render for FileDiffView {
mod tests {
use super::*;
use editor::test::editor_test_context::assert_state_with_diff;
- use gpui::BorrowAppContext;
use gpui::TestAppContext;
use project::{FakeFs, Fs, Project};
- use settings::{DiffViewStyle, SettingsStore};
+ use settings::SettingsStore;
use std::path::PathBuf;
use unindent::unindent;
use util::path;
@@ -388,11 +379,6 @@ mod tests {
cx.update(|cx| {
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
- cx.update_global::(|store, cx| {
- store.update_user_settings(cx, |settings| {
- settings.editor.diff_view_style = Some(DiffViewStyle::Unified);
- });
- });
theme_settings::init(theme::LoadThemes::JustBase, cx);
});
}
@@ -432,9 +418,7 @@ mod tests {
// Verify initial diff
assert_state_with_diff(
- &diff_view.read_with(cx, |diff_view, cx| {
- diff_view.editor.read(cx).rhs_editor().clone()
- }),
+ &diff_view.read_with(cx, |diff_view, _| diff_view.editor.clone()),
cx,
&unindent(
"
@@ -469,9 +453,7 @@ mod tests {
// The diff now reflects the changes to the new file
cx.executor().advance_clock(RECALCULATE_DIFF_DEBOUNCE);
assert_state_with_diff(
- &diff_view.read_with(cx, |diff_view, cx| {
- diff_view.editor.read(cx).rhs_editor().clone()
- }),
+ &diff_view.read_with(cx, |diff_view, _| diff_view.editor.clone()),
cx,
&unindent(
"
@@ -506,9 +488,7 @@ mod tests {
// The diff now reflects the changes to the new file
cx.executor().advance_clock(RECALCULATE_DIFF_DEBOUNCE);
assert_state_with_diff(
- &diff_view.read_with(cx, |diff_view, cx| {
- diff_view.editor.read(cx).rhs_editor().clone()
- }),
+ &diff_view.read_with(cx, |diff_view, _| diff_view.editor.clone()),
cx,
&unindent(
"
@@ -572,10 +552,8 @@ mod tests {
.unwrap();
diff_view.update_in(cx, |diff_view, window, cx| {
- diff_view.editor.update(cx, |splittable, cx| {
- splittable.rhs_editor().update(cx, |editor, cx| {
- editor.insert("modified ", window, cx);
- });
+ diff_view.editor.update(cx, |editor, cx| {
+ editor.insert("modified ", window, cx);
});
});
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 8257b3cf4fb..6f5463d65a3 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -4343,18 +4343,6 @@ impl GitPanel {
editor.max_point(cx).row().0 >= MAX_PANEL_EDITOR_LINES as u32
});
- let max_title_length = GitPanelSettings::get_global(cx).commit_title_max_length;
- let title_exceeds_limit = if max_title_length > 0 {
- self.commit_editor
- .read(cx)
- .text(cx)
- .lines()
- .next()
- .is_some_and(|title| title.len() > max_title_length)
- } else {
- false
- };
-
let footer = v_flex()
.child(PanelRepoFooter::new(
display_name,
@@ -4362,41 +4350,15 @@ impl GitPanel {
head_commit,
Some(git_panel),
))
- .when(title_exceeds_limit, |this| {
- this.child(
- h_flex()
- .px_2()
- .py_1()
- .gap_1()
- .border_t_1()
- .border_color(cx.theme().status().warning_border)
- .bg(cx.theme().status().warning_background.opacity(0.5))
- .child(
- Icon::new(IconName::Warning)
- .size(IconSize::XSmall)
- .color(Color::Warning),
- )
- .child(
- Label::new(format!(
- "Commit message title exceeds {max_title_length}-character limit."
- ))
- .size(LabelSize::Small),
- ),
- )
- })
.child(
panel_editor_container(window, cx)
.id("commit-editor-container")
- .cursor_text()
.relative()
.w_full()
.h(max_height + footer_size)
.border_t_1()
- .border_color(if title_exceeds_limit {
- cx.theme().status().warning_border
- } else {
- cx.theme().colors().border
- })
+ .border_color(cx.theme().colors().border)
+ .cursor_text()
.on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
window.focus(&this.commit_editor.focus_handle(cx), cx);
}))
@@ -4977,46 +4939,57 @@ impl GitPanel {
let toggle_state = self.header_state(header.header);
let section = header.header;
let weak = cx.weak_entity();
+ let show_checkbox_persistently = !matches!(&toggle_state, ToggleState::Unselected);
h_flex()
.id(id)
- .cursor_pointer()
- .group(group_name)
+ .group(group_name.clone())
.h(self.list_item_height())
.w_full()
+ .items_center()
.pl_3()
.pr_1()
- .gap_2()
- .justify_between()
- .hover(|s| s.bg(cx.theme().colors().ghost_element_hover))
+ .gap_1p5()
.border_1()
.border_r_2()
.child(
- Label::new(header.title())
- .color(Color::Muted)
- .size(LabelSize::Small),
+ h_flex().flex_1().child(
+ Label::new(header.title())
+ .color(Color::Muted)
+ .size(LabelSize::Small)
+ .line_height_style(LineHeightStyle::UiLabel)
+ .single_line(),
+ ),
)
.child(
- Checkbox::new(checkbox_id, toggle_state)
- .disabled(!has_write_access)
- .fill()
- .elevation(ElevationIndex::Surface),
- )
- .on_click(move |_, window, cx| {
- if !has_write_access {
- return;
- }
+ div()
+ .flex_none()
+ .cursor_pointer()
+ .child(
+ Checkbox::new(checkbox_id, toggle_state)
+ .disabled(!has_write_access)
+ .fill()
+ .elevation(ElevationIndex::Surface)
+ .on_click_ext(move |_, _, window, cx| {
+ if !has_write_access {
+ return;
+ }
- weak.update(cx, |this, cx| {
- this.toggle_staged_for_entry(
- &GitListEntry::Header(GitHeaderEntry { header: section }),
- window,
- cx,
- );
- cx.stop_propagation();
- })
- .ok();
- })
+ weak.update(cx, |this, cx| {
+ this.toggle_staged_for_entry(
+ &GitListEntry::Header(GitHeaderEntry { header: section }),
+ window,
+ cx,
+ );
+ cx.stop_propagation();
+ })
+ .ok();
+ }),
+ )
+ .when(!show_checkbox_persistently, |this| {
+ this.visible_on_hover(group_name)
+ }),
+ )
.into_any_element()
}
@@ -6150,6 +6123,10 @@ impl RenderOnce for PanelRepoFooter {
util::truncate_and_trailoff(branch_name.trim_ascii(), branch_display_len)
};
+ let repo_selector_trigger = Button::new("repo-selector", truncated_repo_name)
+ .size(ButtonSize::None)
+ .label_size(LabelSize::Small);
+
let repo_selector = PopoverMenu::new("repository-switcher")
.menu({
let project = project;
@@ -6159,9 +6136,8 @@ impl RenderOnce for PanelRepoFooter {
}
})
.trigger_with_tooltip(
- Button::new("repo-selector", truncated_repo_name)
- .size(ButtonSize::None)
- .label_size(LabelSize::Small)
+ repo_selector_trigger
+ .when(single_repo, |this| this.disabled(true).color(Color::Muted))
.truncate(true),
move |_, cx| {
if single_repo {
@@ -6203,7 +6179,7 @@ impl RenderOnce for PanelRepoFooter {
});
h_flex()
- .h_9()
+ .h(px(36.))
.w_full()
.px_2()
.justify_between()
@@ -6220,14 +6196,14 @@ impl RenderOnce for PanelRepoFooter {
Color::Muted
},
))
- .when(!single_repo, |this| {
- this.child(repo_selector).when(show_separator, |this| {
- this.child(
- Label::new("/").size(LabelSize::Small).color(Color::Custom(
- cx.theme().colors().text_muted.opacity(0.4),
- )),
- )
- })
+ .child(repo_selector)
+ .when(show_separator, |this| {
+ this.child(
+ div()
+ .text_sm()
+ .text_color(cx.theme().colors().icon_muted.opacity(0.5))
+ .child("/"),
+ )
})
.child(branch_selector),
)
diff --git a/crates/git_ui/src/git_panel_settings.rs b/crates/git_ui/src/git_panel_settings.rs
index caf4b22dc45..9ccbced249d 100644
--- a/crates/git_ui/src/git_panel_settings.rs
+++ b/crates/git_ui/src/git_panel_settings.rs
@@ -30,7 +30,6 @@ pub struct GitPanelSettings {
pub diff_stats: bool,
pub show_count_badge: bool,
pub starts_open: bool,
- pub commit_title_max_length: usize,
}
#[derive(Default)]
@@ -77,7 +76,6 @@ impl Settings for GitPanelSettings {
diff_stats: git_panel.diff_stats.unwrap(),
show_count_badge: git_panel.show_count_badge.unwrap(),
starts_open: git_panel.starts_open.unwrap(),
- commit_title_max_length: git_panel.commit_title_max_length.unwrap(),
}
}
}
diff --git a/crates/git_ui/src/project_diff.rs b/crates/git_ui/src/project_diff.rs
index 4a300a52574..9f5b65d7560 100644
--- a/crates/git_ui/src/project_diff.rs
+++ b/crates/git_ui/src/project_diff.rs
@@ -359,9 +359,13 @@ impl ProjectDiff {
);
match branch_diff.read(cx).diff_base() {
DiffBase::Head => {}
- DiffBase::Merge { .. } => diff_display_editor.disable_diff_hunk_controls(cx),
+ DiffBase::Merge { .. } => diff_display_editor.set_render_diff_hunk_controls(
+ Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()),
+ cx,
+ ),
}
diff_display_editor.rhs_editor().update(cx, |editor, cx| {
+ editor.disable_diagnostics(cx);
editor.set_show_diff_review_button(true, cx);
match branch_diff.read(cx).diff_base() {
diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs
index 739c3148805..fe2add8177e 100644
--- a/crates/git_ui/src/text_diff_view.rs
+++ b/crates/git_ui/src/text_diff_view.rs
@@ -178,9 +178,14 @@ impl TextDiffView {
window,
cx,
);
- splittable.disable_diff_hunk_controls(cx);
- splittable.rhs_editor().update(cx, |editor, _cx| {
+ splittable.set_render_diff_hunk_controls(
+ Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()),
+ cx,
+ );
+ splittable.rhs_editor().update(cx, |editor, cx| {
editor.start_temporary_diff_override();
+ editor.disable_diagnostics(cx);
+ editor.set_expand_all_diff_hunks(cx);
});
splittable
});
diff --git a/crates/git_ui/src/worktree_service.rs b/crates/git_ui/src/worktree_service.rs
index ba411cb0642..c568b007f76 100644
--- a/crates/git_ui/src/worktree_service.rs
+++ b/crates/git_ui/src/worktree_service.rs
@@ -787,232 +787,23 @@ async fn open_worktree_workspace(
window_handle.update(cx, |multi_workspace, window, cx| {
multi_workspace.activate(new_workspace.clone(), source_for_transfer, window, cx);
- if is_creating_new_worktree {
- new_workspace.update(cx, |workspace, cx| {
- workspace.run_create_worktree_tasks(window, cx);
+ new_workspace.update(cx, |workspace, cx| {
+ workspace.run_create_worktree_tasks(window, cx);
+ });
+ })?;
- if let Some(dock_position) = focused_dock {
+ if is_creating_new_worktree {
+ if let Some(dock_position) = focused_dock {
+ window_handle.update(cx, |_multi_workspace, window, cx| {
+ new_workspace.update(cx, |workspace, cx| {
let dock = workspace.dock_at_position(dock_position);
if let Some(panel) = dock.read(cx).active_panel() {
panel.panel_focus_handle(cx).focus(window, cx);
}
- }
- });
+ });
+ })?;
}
- })?;
+ }
anyhow::Ok(())
}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use fs::Fs;
- use gpui::{App, Task, TestAppContext};
- use language::language_settings::AllLanguageSettings;
- use project::project_settings::ProjectSettings;
- use project::task_store::{TaskSettingsLocation, TaskStore};
- use project::{FakeFs, WorktreeSettings};
- use serde_json::json;
- use settings::{SettingsLocation, SettingsStore};
- use std::path::{Path, PathBuf};
- use std::process::ExitStatus;
- use std::sync::Mutex;
- use task::SpawnInTerminal;
- use theme::LoadThemes;
- use util::path;
- use util::rel_path::rel_path;
- use workspace::{TerminalProvider, WorkspaceSettings};
-
- struct CountingTerminalProvider {
- spawned_task_labels: Arc>>,
- }
-
- impl TerminalProvider for CountingTerminalProvider {
- fn spawn(
- &self,
- task: SpawnInTerminal,
- _window: &mut ui::Window,
- _cx: &mut App,
- ) -> Task>> {
- self.spawned_task_labels
- .lock()
- .expect("terminal spawn mutex should not be poisoned")
- .push(task.label);
- Task::ready(Some(Ok(ExitStatus::default())))
- }
- }
-
- fn init_test(cx: &mut TestAppContext) {
- zlog::init_test();
- cx.update(|cx| {
- let settings_store = SettingsStore::test(cx);
- cx.set_global(settings_store);
- theme_settings::init(LoadThemes::JustBase, cx);
- AllLanguageSettings::register(cx);
- editor::init(cx);
- ProjectSettings::register(cx);
- WorktreeSettings::register(cx);
- WorkspaceSettings::register(cx);
- TaskStore::init(None);
- });
- }
-
- fn install_counting_provider_and_worktree_hook(
- workspace: &Entity,
- spawned_task_labels: &Arc>>,
- main_project_root: &Path,
- hook_tasks_json: &str,
- cx: &mut App,
- ) {
- workspace.update(cx, |workspace, cx| {
- workspace.set_terminal_provider(CountingTerminalProvider {
- spawned_task_labels: spawned_task_labels.clone(),
- });
-
- let project = workspace.project().clone();
- let Some(worktree) = project.read(cx).worktrees(cx).next() else {
- return;
- };
- let worktree = worktree.read(cx);
- let worktree_id = worktree.id();
- let worktree_root = worktree.abs_path().to_path_buf();
- if worktree_root == main_project_root {
- return;
- }
-
- let Some(task_inventory) = project
- .read(cx)
- .task_store()
- .read(cx)
- .task_inventory()
- .cloned()
- else {
- return;
- };
- task_inventory.update(cx, |inventory, _| {
- inventory
- .update_file_based_tasks(
- TaskSettingsLocation::Worktree(SettingsLocation {
- worktree_id,
- path: rel_path(".zed"),
- }),
- Some(hook_tasks_json),
- )
- .expect("should inject create_worktree hook tasks for linked worktree");
- });
- });
- }
-
- #[gpui::test]
- async fn test_create_worktree_hook_does_not_run_when_switching_back_to_main_worktree(
- cx: &mut TestAppContext,
- ) {
- init_test(cx);
-
- let hook_tasks_json = r#"[{"label":"setup worktree","command":"echo","hide":"never","hooks":["create_worktree"]}]"#;
- let fs = FakeFs::new(cx.background_executor.clone());
- cx.update(|cx| ::set_global(fs.clone(), cx));
- fs.insert_tree(
- "/root",
- json!({
- "project": {
- ".git": {},
- ".zed": {
- "tasks.json": hook_tasks_json,
- },
- "src": {
- "main.rs": "fn main() {}",
- },
- },
- }),
- )
- .await;
-
- let main_project_root = PathBuf::from(path!("/root/project"));
- let project = Project::test(fs.clone(), [main_project_root.as_path()], cx).await;
- project
- .update(cx, |project, cx| project.git_scans_complete(cx))
- .await;
-
- let (multi_workspace, cx) =
- cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
-
- let spawned_task_labels = Arc::new(Mutex::new(Vec::new()));
- multi_workspace.update(cx, |multi_workspace, cx| {
- multi_workspace.retain_active_workspace(cx);
- let active_workspace = multi_workspace.workspace().clone();
- install_counting_provider_and_worktree_hook(
- &active_workspace,
- &spawned_task_labels,
- &main_project_root,
- hook_tasks_json,
- cx,
- );
- });
-
- let main_workspace =
- multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
- main_workspace.update_in(cx, |workspace, window, cx| {
- handle_create_worktree(
- workspace,
- &zed_actions::CreateWorktree {
- worktree_name: Some("feature".to_string()),
- branch_target: NewWorktreeBranchTarget::CurrentBranch,
- },
- window,
- None,
- cx,
- );
- });
- cx.run_until_parked();
-
- let active_workspace =
- multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
- cx.update(|_, cx| {
- install_counting_provider_and_worktree_hook(
- &active_workspace,
- &spawned_task_labels,
- &main_project_root,
- hook_tasks_json,
- cx,
- );
- });
- active_workspace.update_in(cx, |workspace, window, cx| {
- workspace.run_create_worktree_tasks(window, cx);
- });
- cx.run_until_parked();
-
- assert_eq!(
- spawned_task_labels
- .lock()
- .expect("terminal spawn mutex should not be poisoned")
- .as_slice(),
- ["setup worktree"],
- "create_worktree hook should run once for the created linked worktree"
- );
-
- active_workspace.update_in(cx, |workspace, window, cx| {
- handle_switch_worktree(
- workspace,
- &zed_actions::SwitchWorktree {
- path: main_project_root.clone(),
- display_name: "project".to_string(),
- },
- window,
- None,
- cx,
- );
- });
- cx.run_until_parked();
-
- assert_eq!(
- spawned_task_labels
- .lock()
- .expect("terminal spawn mutex should not be poisoned")
- .as_slice(),
- ["setup worktree"],
- "switching back to the main worktree should not rerun create_worktree hooks"
- );
- }
-}
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 3642d46a332..3453364a20e 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1680,7 +1680,8 @@ impl App {
self.globals_by_type
.get(&TypeId::of::())
.map(|any_state| any_state.downcast_ref::().unwrap())
- .unwrap_or_else(|| panic!("no state of type {} exists", type_name::()))
+ .with_context(|| format!("no state of type {} exists", type_name::()))
+ .unwrap()
}
/// Access the global of the given type if a value has been assigned.
@@ -1698,7 +1699,8 @@ impl App {
self.globals_by_type
.get_mut(&global_type)
.and_then(|any_state| any_state.downcast_mut::())
- .unwrap_or_else(|| panic!("no state of type {} exists", type_name::()))
+ .with_context(|| format!("no state of type {} exists", type_name::()))
+ .unwrap()
}
/// Access the global of the given type mutably. A default value is assigned if a global of this type has not
@@ -1733,7 +1735,7 @@ impl App {
*self
.globals_by_type
.remove(&global_type)
- .unwrap_or_else(|| panic!("no global added for {}", type_name::()))
+ .unwrap_or_else(|| panic!("no global added for {}", std::any::type_name::()))
.downcast()
.unwrap()
}
diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs
index df6403460d9..bdda213dfd0 100644
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -738,7 +738,7 @@ pub trait InteractiveElement: Sized {
fn key_context(mut self, key_context: C) -> Self
where
C: TryInto,
- E: std::fmt::Display,
+ E: Debug,
{
if let Some(key_context) = key_context.try_into().log_err() {
self.interactivity().key_context = Some(key_context);
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index 5a88d81c18d..c7409687faf 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -125,6 +125,14 @@ impl FollowState {
*self = FollowState::Tail { is_following: true };
}
}
+
+ fn stop_following(&mut self) {
+ if let FollowState::Tail { is_following: true } = self {
+ *self = FollowState::Tail {
+ is_following: false,
+ };
+ }
+ }
}
/// Whether the list is scrolling from top to bottom or bottom to top.
@@ -464,9 +472,7 @@ impl ListState {
let state = &mut *self.0.borrow_mut();
if distance < px(0.) {
- if let FollowState::Tail { is_following } = &mut state.follow_state {
- *is_following = false;
- }
+ state.follow_state.stop_following();
}
let mut cursor = state.items.cursor::(());
@@ -544,9 +550,7 @@ impl ListState {
}
if scroll_top.item_ix < item_count {
- if let FollowState::Tail { is_following } = &mut state.follow_state {
- *is_following = false;
- }
+ state.follow_state.stop_following();
}
state.logical_scroll_top = Some(scroll_top);
@@ -727,10 +731,8 @@ impl StateInner {
});
}
- if let FollowState::Tail { is_following } = &mut self.follow_state {
- if delta.y > px(0.) {
- *is_following = false;
- }
+ if delta.y > px(0.) {
+ self.follow_state.stop_following();
}
if let Some(handler) = self.scroll_handler.as_mut() {
@@ -1135,7 +1137,7 @@ impl StateInner {
content_height - self.scrollbar_drag_start_height.unwrap_or(content_height);
let new_scroll_top = (point.y - drag_offset).abs().max(px(0.)).min(scroll_max);
- self.follow_state = FollowState::Normal;
+ self.follow_state.stop_following();
if self.alignment == ListAlignment::Bottom && new_scroll_top == scroll_max {
self.logical_scroll_top = None;
@@ -2014,14 +2016,11 @@ mod test {
);
}
- /// Calling `set_follow_mode(FollowState::Normal)` or dragging the scrollbar should
- /// fully disengage follow_tail — clearing any suspended state so
- /// follow_tail won’t auto-re-engage.
#[gpui::test]
- fn test_follow_tail_suspended_state_cleared_by_explicit_actions(cx: &mut TestAppContext) {
+ fn test_follow_tail_reengages_after_scrollbar_disengagement(cx: &mut TestAppContext) {
let cx = cx.add_empty_window();
- // 10 items × 50px = 500px total, 200px viewport.
+ // 10 items × 50px = 500px total, 200px viewport, scroll_max = 300px.
let state = ListState::new(10, crate::ListAlignment::Top, px(0.)).measure_all();
struct TestView(ListState);
@@ -2038,59 +2037,24 @@ mod test {
let view = cx.update(|_, cx| cx.new(|_| TestView(state.clone())));
state.set_follow_mode(FollowMode::Tail);
- // --- Part 1: set_follow_mode(FollowState::Normal) clears suspended state ---
-
cx.draw(point(px(0.), px(0.)), size(px(100.), px(200.)), |_, _| {
view.clone().into_any_element()
});
+ assert!(state.is_following_tail());
- // Scroll up — suspends follow_tail.
- cx.simulate_event(ScrollWheelEvent {
- position: point(px(50.), px(100.)),
- delta: ScrollDelta::Pixels(point(px(0.), px(50.))),
- ..Default::default()
- });
+ // Drag the scrollbar up to the middle — follow_tail should suspend.
+ state.set_offset_from_scrollbar(point(px(0.), px(150.)));
assert!(!state.is_following_tail());
- // Scroll back to the bottom — should re-engage follow_tail.
- cx.simulate_event(ScrollWheelEvent {
- position: point(px(50.), px(100.)),
- delta: ScrollDelta::Pixels(point(px(0.), px(-10000.))),
- ..Default::default()
- });
-
+ // Drag the scrollbar back to the bottom — follow_tail should re-engage
+ // on the next paint.
+ state.set_offset_from_scrollbar(point(px(0.), px(300.)));
cx.draw(point(px(0.), px(0.)), size(px(100.), px(200.)), |_, _| {
- view.clone().into_any_element()
+ view.into_any_element()
});
assert!(
state.is_following_tail(),
- "follow_tail should re-engage after scrolling back to the bottom"
- );
-
- // --- Part 2: scrollbar drag clears suspended state ---
-
- cx.draw(point(px(0.), px(0.)), size(px(100.), px(200.)), |_, _| {
- view.clone().into_any_element()
- });
-
- // Drag the scrollbar to the middle — should clear suspended state.
- state.set_offset_from_scrollbar(point(px(0.), px(150.)));
-
- // Scroll to the bottom.
- cx.simulate_event(ScrollWheelEvent {
- position: point(px(50.), px(100.)),
- delta: ScrollDelta::Pixels(point(px(0.), px(-10000.))),
- ..Default::default()
- });
-
- // Paint — should NOT re-engage because the scrollbar drag
- // cleared the suspended state.
- cx.draw(point(px(0.), px(0.)), size(px(100.), px(200.)), |_, _| {
- view.clone().into_any_element()
- });
- assert!(
- !state.is_following_tail(),
- "follow_tail should not re-engage after scrollbar drag cleared the suspended state"
+ "follow_tail should re-engage after scrolling back to the bottom via the scrollbar"
);
}
}
diff --git a/crates/gpui/src/executor.rs b/crates/gpui/src/executor.rs
index ab253472ad8..f66f5844787 100644
--- a/crates/gpui/src/executor.rs
+++ b/crates/gpui/src/executor.rs
@@ -1,7 +1,7 @@
use crate::{App, PlatformDispatcher, PlatformScheduler};
use futures::channel::mpsc;
use futures::prelude::*;
-use gpui_util::{TryFutureExt, TryFutureExtBacktrace};
+use gpui_util::TryFutureExt;
use scheduler::Instant;
use scheduler::Scheduler;
use std::{
@@ -84,7 +84,7 @@ impl Task {
impl Task>
where
T: 'static,
- E: 'static + std::fmt::Display,
+ E: 'static + Debug,
{
/// Run the task to completion in the background and log any errors that occur.
#[track_caller]
@@ -96,22 +96,6 @@ where
}
}
-impl Task>
-where
- T: 'static,
- E: 'static + std::fmt::Debug,
-{
- /// Like [`Self::detach_and_log_err`], but uses `{:?}` formatting on failure so `anyhow::Error`
- /// values emit their full backtrace. Prefer `detach_and_log_err` unless a backtrace is wanted.
- #[track_caller]
- pub fn detach_and_log_err_with_backtrace(self, cx: &App) {
- let location = *core::panic::Location::caller();
- cx.foreground_executor()
- .spawn(self.log_tracked_err_with_backtrace(location))
- .detach();
- }
-}
-
impl std::future::Future for Task {
type Output = T;
diff --git a/crates/gpui/src/profiler.rs b/crates/gpui/src/profiler.rs
index 1405b4d0496..009afb9099e 100644
--- a/crates/gpui/src/profiler.rs
+++ b/crates/gpui/src/profiler.rs
@@ -3,7 +3,10 @@ use std::{
cell::LazyCell,
collections::{HashMap, VecDeque},
hash::{DefaultHasher, Hash, Hasher},
- sync::Arc,
+ sync::{
+ Arc,
+ atomic::{AtomicBool, Ordering},
+ },
thread::ThreadId,
};
@@ -348,6 +351,9 @@ impl Drop for ThreadTimings {
#[doc(hidden)]
pub fn add_task_timing(timing: TaskTiming) {
+ if !PROFILER_ENABLED.load(Ordering::Acquire) {
+ return;
+ }
THREAD_TIMINGS.with(|timings| {
timings.lock().add_task_timing(timing);
});
@@ -357,3 +363,28 @@ pub fn add_task_timing(timing: TaskTiming) {
pub fn get_current_thread_task_timings() -> ThreadTaskTimings {
THREAD_TIMINGS.with(|timings| timings.lock().get_thread_task_timings())
}
+
+static PROFILER_ENABLED: AtomicBool = AtomicBool::new(false);
+
+/// Enables or disables task timing collection at runtime.
+///
+/// When transitioning from enabled to disabled, `add_task_timing` becomes a
+/// no-op and the existing per-thread buffers are cleared so stale data isn't
+/// reported after a later re-enable. Calls with the current value are a no-op.
+pub fn set_enabled(enabled: bool) -> bool {
+ if PROFILER_ENABLED.swap(enabled, Ordering::AcqRel) == enabled {
+ return false;
+ }
+
+ if !enabled {
+ for global in GLOBAL_THREAD_TIMINGS.lock().iter() {
+ if let Some(timings) = global.timings.upgrade() {
+ let mut timings = timings.lock();
+ timings.timings.clear();
+ timings.timings.shrink_to_fit();
+ timings.total_pushed = 0;
+ }
+ }
+ }
+ true
+}
diff --git a/crates/gpui/src/text_system/line.rs b/crates/gpui/src/text_system/line.rs
index 437ef48cb17..9c6ffdbe3f6 100644
--- a/crates/gpui/src/text_system/line.rs
+++ b/crates/gpui/src/text_system/line.rs
@@ -208,16 +208,8 @@ impl ShapedLine {
}
// Split text
- let left_text = if byte_index == self.text.len() {
- self.text.clone()
- } else {
- SharedString::new(&self.text[..byte_index])
- };
- let right_text = if byte_index == 0 {
- self.text.clone()
- } else {
- SharedString::new(&self.text[byte_index..])
- };
+ let left_text = SharedString::new(self.text[..byte_index].to_string());
+ let right_text = SharedString::new(self.text[byte_index..].to_string());
let left_width = x_offset;
let right_width = self.layout.width - left_width;
diff --git a/crates/gpui_linux/src/linux/wayland/client.rs b/crates/gpui_linux/src/linux/wayland/client.rs
index 3b8ca0f4502..10f4aab0db1 100644
--- a/crates/gpui_linux/src/linux/wayland/client.rs
+++ b/crates/gpui_linux/src/linux/wayland/client.rs
@@ -2237,13 +2237,7 @@ impl Dispatch for WaylandClientStatePtr {
let paths: SmallVec<[_; 2]> = file_list
.lines()
.filter_map(|path| Url::parse(path).log_err())
- .filter_map(|url| match url.to_file_path() {
- Ok(url) => Some(url),
- Err(()) => {
- log::error!("Failed turn {url:?} into a file path");
- None
- }
- })
+ .filter_map(|url| url.to_file_path().log_err())
.collect();
let position = Point::new(x.into(), y.into());
diff --git a/crates/gpui_linux/src/linux/x11/client.rs b/crates/gpui_linux/src/linux/x11/client.rs
index 07d1596a2f7..70c0392d43c 100644
--- a/crates/gpui_linux/src/linux/x11/client.rs
+++ b/crates/gpui_linux/src/linux/x11/client.rs
@@ -908,13 +908,7 @@ impl X11Client {
let paths: SmallVec<[_; 2]> = file_list
.lines()
.filter_map(|path| Url::parse(path).log_err())
- .filter_map(|url| match url.to_file_path() {
- Ok(url) => Some(url),
- Err(()) => {
- log::error!("Failed turn {url:?} into a file path");
- None
- }
- })
+ .filter_map(|url| url.to_file_path().log_err())
.collect();
let input = PlatformInput::FileDrop(FileDropEvent::Entered {
position: state.xdnd_state.position,
diff --git a/crates/gpui_util/src/lib.rs b/crates/gpui_util/src/lib.rs
index eac1e2559a2..ae56c2ccd0e 100644
--- a/crates/gpui_util/src/lib.rs
+++ b/crates/gpui_util/src/lib.rs
@@ -79,12 +79,6 @@ pub trait ResultExt {
type Ok;
fn log_err(self) -> Option;
- /// Like [`ResultExt::log_err`], but uses `{:?}` formatting so `anyhow::Error` values emit their
- /// full backtrace. Reach for this only when a backtrace is genuinely wanted — most call sites
- /// should stick with `log_err` / `warn_on_err`, whose output is a single chained error message.
- fn log_err_with_backtrace(self) -> Option
- where
- E: std::fmt::Debug;
/// Assert that this result should never be an error in development or tests.
fn debug_assert_ok(self, reason: &str) -> Self;
fn warn_on_err(self) -> Option;
@@ -96,7 +90,7 @@ pub trait ResultExt {
impl ResultExt for Result
where
- E: std::fmt::Display,
+ E: std::fmt::Debug,
{
type Ok = T;
@@ -105,28 +99,10 @@ where
self.log_with_level(log::Level::Error)
}
- #[track_caller]
- fn log_err_with_backtrace(self) -> Option
- where
- E: std::fmt::Debug,
- {
- match self {
- Ok(value) => Some(value),
- Err(error) => {
- log_error_with_caller(
- *Location::caller(),
- DebugAsDisplay(&error),
- log::Level::Error,
- );
- None
- }
- }
- }
-
#[track_caller]
fn debug_assert_ok(self, reason: &str) -> Self {
if let Err(error) = &self {
- debug_panic!("{reason} - {error:#}");
+ debug_panic!("{reason} - {error:?}");
}
self
}
@@ -157,7 +133,7 @@ where
fn log_error_with_caller(caller: core::panic::Location<'_>, error: E, level: log::Level)
where
- E: std::fmt::Display,
+ E: std::fmt::Debug,
{
#[cfg(not(windows))]
let file = caller.file();
@@ -180,7 +156,7 @@ where
&log::Record::builder()
.target(module_path.as_deref().unwrap_or(""))
.module_path(file.as_deref())
- .args(format_args!("{:#}", error))
+ .args(format_args!("{:?}", error))
.file(Some(caller.file()))
.line(Some(caller.line()))
.level(level)
@@ -188,20 +164,10 @@ where
);
}
-pub fn log_err(error: &E) {
+pub fn log_err(error: &E) {
log_error_with_caller(*Location::caller(), error, log::Level::Error);
}
-// Forces `{:?}` formatting through a `Display`-bounded logging helper so `anyhow::Error` emits a
-// backtrace instead of the single-line chained message produced by its `Display`/`{:#}` forms.
-struct DebugAsDisplay<'a, E>(&'a E);
-
-impl std::fmt::Display for DebugAsDisplay<'_, E> {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- write!(f, "{:?}", self.0)
- }
-}
-
pub trait TryFutureExt {
fn log_err(self) -> LogErrorFuture
where
@@ -219,25 +185,10 @@ pub trait TryFutureExt {
Self: Sized;
}
-/// `{:?}`-formatting companion to [`TryFutureExt`]; emits a backtrace for `anyhow::Error`. Prefer
-/// [`TryFutureExt`] unless a backtrace is genuinely wanted.
-pub trait TryFutureExtBacktrace {
- fn log_err_with_backtrace(self) -> LogErrorWithBacktraceFuture
- where
- Self: Sized;
-
- fn log_tracked_err_with_backtrace(
- self,
- location: core::panic::Location<'static>,
- ) -> LogErrorWithBacktraceFuture
- where
- Self: Sized;
-}
-
impl TryFutureExt for F
where
F: Future