Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use read() over read_with() to improve readability in simple cases (#31455)

Browse source 
Follow up to: #31263 

Release Notes:

- N/A
This commit is contained in:
Joseph T. Lyons 2025-05-26 16:14:07 -04:00 • committed by GitHub
parent 5bafb2b160
commit 534bb0620d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 80 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

7
crates/agent/src/message_editor.rs
View file

@ -1185,9 +1185,10 @@ impl MessageEditor {
fn reload_context(&mut self, cx: &mut Context<Self>) -> Task<Option<ContextLoadResult>> { fn reload_context(&mut self, cx: &mut Context<Self>) -> Task<Option<ContextLoadResult>> {
let load_task = cx.spawn(async move |this, cx| { let load_task = cx.spawn(async move |this, cx| {
let Ok(load_task) = this.update(cx, |this, cx| { let Ok(load_task) = this.update(cx, |this, cx| {
let new_context = this.context_store.read_with(cx, |context_store, cx| { let new_context = this
context_store.new_context_for_thread(this.thread.read(cx), None) .context_store
}); .read(cx)
.new_context_for_thread(this.thread.read(cx), None);
load_context(new_context, &this.project, &this.prompt_store, cx) load_context(new_context, &this.project, &this.prompt_store, cx)
}) else { }) else {
return; return;

5
crates/assistant_context_editor/src/context.rs
View file

@ -1730,9 +1730,8 @@ impl AssistantContext {
merge_same_roles, merge_same_roles,
} => { } => {
if !merge_same_roles && Some(role) != last_role { if !merge_same_roles && Some(role) != last_role {
let offset = this.buffer.read_with(cx, |buffer, _cx| { let buffer = this.buffer.read(cx);
insert_position.to_offset(buffer) let offset = insert_position.to_offset(buffer);
});
this.insert_message_at_offset( this.insert_message_at_offset(
offset, offset,
role, role,

80
crates/debugger_ui/src/debugger_ui.rs
View file

@ -66,77 +66,77 @@ pub fn init(cx: &mut App) {
}) })
.register_action(|workspace, _: &Pause, _, cx| { .register_action(|workspace, _: &Pause, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.pause_thread(cx)) active_item.update(cx, |item, cx| item.pause_thread(cx))
} }
} }
}) })
.register_action(|workspace, _: &Restart, _, cx| { .register_action(|workspace, _: &Restart, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.restart_session(cx)) active_item.update(cx, |item, cx| item.restart_session(cx))
} }
} }
}) })
.register_action(|workspace, _: &Continue, _, cx| { .register_action(|workspace, _: &Continue, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.continue_thread(cx)) active_item.update(cx, |item, cx| item.continue_thread(cx))
} }
} }
}) })
.register_action(|workspace, _: &StepInto, _, cx| { .register_action(|workspace, _: &StepInto, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.step_in(cx)) active_item.update(cx, |item, cx| item.step_in(cx))
} }
} }
}) })
.register_action(|workspace, _: &StepOver, _, cx| { .register_action(|workspace, _: &StepOver, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.step_over(cx)) active_item.update(cx, |item, cx| item.step_over(cx))
} }
} }
}) })
.register_action(|workspace, _: &StepBack, _, cx| { .register_action(|workspace, _: &StepBack, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.step_back(cx)) active_item.update(cx, |item, cx| item.step_back(cx))
} }
} }
}) })
.register_action(|workspace, _: &Stop, _, cx| { .register_action(|workspace, _: &Stop, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
cx.defer(move |cx| { cx.defer(move |cx| {
active_item.update(cx, |item, cx| item.stop_thread(cx)) active_item.update(cx, |item, cx| item.stop_thread(cx))
}) })
@ -145,11 +145,11 @@ pub fn init(cx: &mut App) {
}) })
.register_action(|workspace, _: &ToggleIgnoreBreakpoints, _, cx| { .register_action(|workspace, _: &ToggleIgnoreBreakpoints, _, cx| {
if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) { if let Some(debug_panel) = workspace.panel::<DebugPanel>(cx) {
if let Some(active_item) = debug_panel.read_with(cx, |panel, cx| { if let Some(active_item) = debug_panel
panel .read(cx)
.active_session() .active_session()
.map(|session| session.read(cx).running_state().clone()) .map(|session| session.read(cx).running_state().clone())
}) { {
active_item.update(cx, |item, cx| item.toggle_ignore_breakpoints(cx)) active_item.update(cx, |item, cx| item.toggle_ignore_breakpoints(cx))
} }
} }

22
crates/editor/src/editor.rs
View file

@ -6601,8 +6601,7 @@ impl Editor {
} }
// Store the transaction ID and selections before applying the edit // Store the transaction ID and selections before applying the edit
let transaction_id_prev = let transaction_id_prev = self.buffer.read(cx).last_transaction_id(cx);
self.buffer.read_with(cx, |b, cx| b.last_transaction_id(cx));
let snapshot = self.buffer.read(cx).snapshot(cx); let snapshot = self.buffer.read(cx).snapshot(cx);
let last_edit_end = edits.last().unwrap().0.end.bias_right(&snapshot); let last_edit_end = edits.last().unwrap().0.end.bias_right(&snapshot);
@ -6616,9 +6615,7 @@ impl Editor {
}); });
let selections = self.selections.disjoint_anchors(); let selections = self.selections.disjoint_anchors();
if let Some(transaction_id_now) = if let Some(transaction_id_now) = self.buffer.read(cx).last_transaction_id(cx) {
self.buffer.read_with(cx, |b, cx| b.last_transaction_id(cx))
{
let has_new_transaction = transaction_id_prev != Some(transaction_id_now); let has_new_transaction = transaction_id_prev != Some(transaction_id_now);
if has_new_transaction { if has_new_transaction {
self.selection_history self.selection_history
@ -7114,9 +7111,10 @@ impl Editor {
for (buffer_snapshot, range, excerpt_id) in for (buffer_snapshot, range, excerpt_id) in
multi_buffer_snapshot.range_to_buffer_ranges(range) multi_buffer_snapshot.range_to_buffer_ranges(range)
{ {
let Some(buffer) = project.read_with(cx, |this, cx| { let Some(buffer) = project
this.buffer_for_id(buffer_snapshot.remote_id(), cx) .read(cx)
}) else { .buffer_for_id(buffer_snapshot.remote_id(), cx)
else {
continue; continue;
}; };
let breakpoints = breakpoint_store.read(cx).breakpoints( let breakpoints = breakpoint_store.read(cx).breakpoints(
@ -9724,7 +9722,7 @@ impl Editor {
})?; })?;
let enclosing_excerpt = breakpoint_position.excerpt_id; let enclosing_excerpt = breakpoint_position.excerpt_id;
let buffer = project.read_with(cx, |project, cx| project.buffer_for_id(buffer_id, cx))?; let buffer = project.read(cx).buffer_for_id(buffer_id, cx)?;
let buffer_snapshot = buffer.read(cx).snapshot(); let buffer_snapshot = buffer.read(cx).snapshot();
let row = buffer_snapshot let row = buffer_snapshot
@ -15153,7 +15151,7 @@ impl Editor {
} }
}; };
let transaction_id_prev = buffer.read_with(cx, |b, cx| b.last_transaction_id(cx)); let transaction_id_prev = buffer.read(cx).last_transaction_id(cx);
let selections_prev = transaction_id_prev let selections_prev = transaction_id_prev
.and_then(|transaction_id_prev| { .and_then(|transaction_id_prev| {
// default to selections as they were after the last edit, if we have them, // default to selections as they were after the last edit, if we have them,
@ -19516,9 +19514,7 @@ impl CollaborationHub for Entity<Project> {
fn user_names(&self, cx: &App) -> HashMap<u64, SharedString> { fn user_names(&self, cx: &App) -> HashMap<u64, SharedString> {
let this = self.read(cx); let this = self.read(cx);
let user_ids = this.collaborators().values().map(|c| c.user_id); let user_ids = this.collaborators().values().map(|c| c.user_id);
this.user_store().read_with(cx, |user_store, cx| { this.user_store().read(cx).participant_names(user_ids, cx)
user_store.participant_names(user_ids, cx)
})
} }
} }

26
crates/editor/src/element.rs
View file

@ -1533,9 +1533,7 @@ impl EditorElement {
window: &mut Window, window: &mut Window,
cx: &mut App, cx: &mut App,
) -> Option<MinimapLayout> { ) -> Option<MinimapLayout> {
let minimap_editor = self let minimap_editor = self.editor.read(cx).minimap().cloned()?;
.editor
.read_with(cx, |editor, _| editor.minimap().cloned())?;
let minimap_settings = EditorSettings::get_global(cx).minimap; let minimap_settings = EditorSettings::get_global(cx).minimap;
@ -1581,12 +1579,10 @@ impl EditorElement {
); );
let minimap_line_height = self.get_minimap_line_height( let minimap_line_height = self.get_minimap_line_height(
minimap_editor minimap_editor
.read_with(cx, |editor, _| { .read(cx)
editor .text_style_refinement
.text_style_refinement .as_ref()
.as_ref() .and_then(|refinement| refinement.font_size)
.and_then(|refinement| refinement.font_size)
})
.unwrap_or(MINIMAP_FONT_SIZE), .unwrap_or(MINIMAP_FONT_SIZE),
window, window,
cx, cx,
@ -7562,14 +7558,14 @@ impl Element for EditorElement {
let scrollbars_shown = settings.scrollbar.show != ShowScrollbar::Never; let scrollbars_shown = settings.scrollbar.show != ShowScrollbar::Never;
let vertical_scrollbar_width = (scrollbars_shown let vertical_scrollbar_width = (scrollbars_shown
&& settings.scrollbar.axes.vertical && settings.scrollbar.axes.vertical
&& self && self.editor.read(cx).show_scrollbars)
.editor .then_some(style.scrollbar_width)
.read_with(cx, |editor, _| editor.show_scrollbars)) .unwrap_or_default();
.then_some(style.scrollbar_width)
.unwrap_or_default();
let minimap_width = self let minimap_width = self
.editor .editor
.read_with(cx, |editor, _| editor.minimap().is_some()) .read(cx)
.minimap()
.is_some()
.then(|| match settings.minimap.show { .then(|| match settings.minimap.show {
ShowMinimap::Auto => { ShowMinimap::Auto => {
scrollbars_shown.then_some(MinimapLayout::MINIMAP_WIDTH) scrollbars_shown.then_some(MinimapLayout::MINIMAP_WIDTH)

15
crates/editor/src/jsx_tag_auto_close.rs
View file

@ -458,13 +458,12 @@ pub(crate) fn handle_from(
let ensure_no_edits_since_start = || -> Option<()> { let ensure_no_edits_since_start = || -> Option<()> {
let has_edits_since_start = this let has_edits_since_start = this
.read_with(cx, |this, cx| { .read_with(cx, |this, cx| {
this.buffer.read_with(cx, |buffer, cx| { this.buffer
buffer.buffer(buffer_id).map_or(true, |buffer| { .read(cx)
buffer.read_with(cx, |buffer, _| { .buffer(buffer_id)
buffer.has_edits_since(&buffer_version_initial) .map_or(true, |buffer| {
}) buffer.read(cx).has_edits_since(&buffer_version_initial)
}) })
})
}) })
.ok()?; .ok()?;
@ -507,9 +506,7 @@ pub(crate) fn handle_from(
ensure_no_edits_since_start()?; ensure_no_edits_since_start()?;
let multi_buffer_snapshot = this let multi_buffer_snapshot = this
.read_with(cx, |this, cx| { .read_with(cx, |this, cx| this.buffer.read(cx).snapshot(cx))
this.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx))
})
.ok()?; .ok()?;
let mut base_selections = Vec::new(); let mut base_selections = Vec::new();

7
crates/language_tools/src/lsp_log.rs
View file

@ -842,9 +842,10 @@ impl LspLogView {
) { ) {
let typ = self let typ = self
.log_store .log_store
.read_with(cx, |v, _| { .read(cx)
v.language_servers.get(&server_id).map(|v| v.log_level) .language_servers
}) .get(&server_id)
.map(|v| v.log_level)
.unwrap_or(MessageType::LOG); .unwrap_or(MessageType::LOG);
let log_contents = self let log_contents = self
.log_store .log_store

8
crates/project/src/debugger/session.rs
View file

@ -222,9 +222,8 @@ impl LocalMode {
) -> Task<()> { ) -> Task<()> {
let breakpoints = let breakpoints =
breakpoint_store breakpoint_store
.read_with(cx, |store, cx| { .read(cx)
store.source_breakpoints_from_path(&abs_path, cx) .source_breakpoints_from_path(&abs_path, cx)
})
.into_iter() .into_iter()
.filter(|bp| bp.state.is_enabled()) .filter(|bp| bp.state.is_enabled())
.chain(self.tmp_breakpoint.iter().filter_map(|breakpoint| { .chain(self.tmp_breakpoint.iter().filter_map(|breakpoint| {
@ -303,8 +302,7 @@ impl LocalMode {
cx: &App, cx: &App,
) -> Task<HashMap<Arc<Path>, anyhow::Error>> { ) -> Task<HashMap<Arc<Path>, anyhow::Error>> {
let mut breakpoint_tasks = Vec::new(); let mut breakpoint_tasks = Vec::new();
let breakpoints = let breakpoints = breakpoint_store.read(cx).all_source_breakpoints(cx);
breakpoint_store.read_with(cx, |store, cx| store.all_source_breakpoints(cx));
let mut raw_breakpoints = breakpoint_store.read_with(cx, |this, _| this.all_breakpoints()); let mut raw_breakpoints = breakpoint_store.read_with(cx, |this, _| this.all_breakpoints());
debug_assert_eq!(raw_breakpoints.len(), breakpoints.len()); debug_assert_eq!(raw_breakpoints.len(), breakpoints.len());
let session_id = self.client.id(); let session_id = self.client.id();

4
crates/project/src/project.rs
View file

@ -3870,9 +3870,7 @@ impl Project {
} }
pub fn find_worktree(&self, abs_path: &Path, cx: &App) -> Option<(Entity<Worktree>, PathBuf)> { pub fn find_worktree(&self, abs_path: &Path, cx: &App) -> Option<(Entity<Worktree>, PathBuf)> {
self.worktree_store.read_with(cx, |worktree_store, cx| { self.worktree_store.read(cx).find_worktree(abs_path, cx)
worktree_store.find_worktree(abs_path, cx)
})
} }
pub fn is_shared(&self) -> bool { pub fn is_shared(&self) -> bool {