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

Move "async move" a few characters to the left in cx.spawn() (#26758)

Browse source 
This is the core change:
https://github.com/zed-industries/zed/pull/26758/files#diff-044302c0d57147af17e68a0009fee3e8dcdfb4f32c27a915e70cfa80e987f765R1052

TODO:
- [x] Use AsyncFn instead of Fn() -> Future in GPUI spawn methods
- [x] Implement it in the whole app
- [x] Implement it in the debugger 
- [x] Glance at the RPC crate, and see if those box future methods can
be switched over. Answer: It can't directly, as you can't make an
AsyncFn* into a trait object. There's ways around that, but they're all
more complex than just keeping the code as is.
- [ ] Fix platform specific code

Release Notes:

- N/A
This commit is contained in:
Mikayla Maki 2025-03-18 19:09:02 -07:00 • committed by GitHub
parent 7f2e3fb5bd
commit 1aefa5178b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
256 changed files with 3110 additions and 3200 deletions
Download patch file Download diff file Expand all files Collapse all files

12
crates/project/src/debugger/breakpoint_store.rs
View file

@ -448,7 +448,7 @@ impl BreakpointStore {
) -> Task<Result<()>> {
if let BreakpointStoreMode::Local(mode) = &self.mode {
let mode = mode.clone();
cx.spawn(move |this, mut cx| async move {
cx.spawn(async move |this, cx| {
let mut new_breakpoints = BTreeMap::default();
for (path, bps) in breakpoints {
if bps.is_empty() {
@ -456,13 +456,13 @@ impl BreakpointStore {
}
let (worktree, relative_path) = mode
.worktree_store
.update(&mut cx, |this, cx| {
.update(cx, |this, cx| {
this.find_or_create_worktree(&path, false, cx)
})?
.await?;
let buffer = mode
.buffer_store
.update(&mut cx, |this, cx| {
.update(cx, |this, cx| {
let path = ProjectPath {
worktree_id: worktree.read(cx).id(),
path: relative_path.into(),
@ -474,10 +474,10 @@ impl BreakpointStore {
log::error!("Todo: Serialized breakpoints which do not have buffer (yet)");
continue;
};
let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
let mut breakpoints_for_file =
this.update(&mut cx, |_, cx| BreakpointsInFile::new(buffer, cx))?;
this.update(cx, |_, cx| BreakpointsInFile::new(buffer, cx))?;
for bp in bps {
let position = snapshot.anchor_before(PointUtf16::new(bp.position, 0));
@ -487,7 +487,7 @@ impl BreakpointStore {
}
new_breakpoints.insert(path, breakpoints_for_file);
}
this.update(&mut cx, |this, cx| {
this.update(cx, |this, cx| {
this.breakpoints = new_breakpoints;
cx.notify();
})?;

22
crates/project/src/debugger/dap_store.rs
View file

@ -149,12 +149,12 @@ impl DapStore {
let (start_debugging_tx, mut message_rx) =
futures::channel::mpsc::unbounded::<(SessionId, Message)>();
let _start_debugging_task = cx.spawn(move |this, mut cx| async move {
let _start_debugging_task = cx.spawn(async move |this, cx| {
while let Some((session_id, message)) = message_rx.next().await {
match message {
Message::Request(request) => {
let _ = this
.update(&mut cx, |this, cx| {
.update(cx, |this, cx| {
if request.command == StartDebugging::COMMAND {
this.handle_start_debugging_request(session_id, request, cx)
.detach_and_log_err(cx);
@ -361,11 +361,11 @@ impl DapStore {
cx,
);
let task = cx.spawn(|this, mut cx| async move {
let task = cx.spawn(async move |this, cx| {
let session = match start_client_task.await {
Ok(session) => session,
Err(error) => {
this.update(&mut cx, |_, cx| {
this.update(cx, |_, cx| {
cx.emit(DapStoreEvent::Notification(error.to_string()));
})
.log_err();
@ -376,21 +376,21 @@ impl DapStore {
// we have to insert the session early, so we can handle reverse requests
// that need the session to be available
this.update(&mut cx, |store, cx| {
this.update(cx, |store, cx| {
store.sessions.insert(session_id, session.clone());
cx.emit(DapStoreEvent::DebugClientStarted(session_id));
cx.notify();
})?;
match session
.update(&mut cx, |session, cx| {
.update(cx, |session, cx| {
session.initialize_sequence(initialized_rx, cx)
})?
.await
{
Ok(_) => {}
Err(error) => {
this.update(&mut cx, |this, cx| {
this.update(cx, |this, cx| {
cx.emit(DapStoreEvent::Notification(error.to_string()));
this.shutdown_session(session_id, cx)
@ -456,7 +456,7 @@ impl DapStore {
);
let request_seq = request.seq;
cx.spawn(|_, mut cx| async move {
cx.spawn(async move |_, cx| {
let (success, body) = match new_session_task.await {
Ok(_) => (true, None),
Err(error) => (
@ -476,7 +476,7 @@ impl DapStore {
};
parent_session
.update(&mut cx, |session, cx| {
.update(cx, |session, cx| {
session.respond_to_client(
request_seq,
success,
@ -572,7 +572,7 @@ impl DapStore {
cx.notify();
let session = session.downgrade();
cx.spawn(|_, mut cx| async move {
cx.spawn(async move |_, cx| {
let (success, body) = match rx.next().await {
Some(Ok(pid)) => (
true,
@ -615,7 +615,7 @@ impl DapStore {
};
session
.update(&mut cx, |session, cx| {
.update(cx, |session, cx| {
session.respond_to_client(
seq,
success,

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

@ -191,8 +191,8 @@ impl LocalMode {
messages_tx: futures::channel::mpsc::UnboundedSender<Message>,
cx: AsyncApp,
) -> Task<Result<(Self, Capabilities)>> {
cx.spawn(move |mut cx| async move {
let (adapter, binary) = Self::get_adapter_binary(&config, &delegate, &mut cx).await?;
cx.spawn(async move |cx| {
let (adapter, binary) = Self::get_adapter_binary(&config, &delegate, cx).await?;
let message_handler = Box::new(move |message| {
messages_tx.unbounded_send(message).ok();
@ -439,7 +439,7 @@ impl LocalMode {
let configuration_sequence = cx.spawn({
let this = self.clone();
move |cx| async move {
async move |cx| {
initialized_rx.await?;
// todo(debugger) figure out if we want to handle a breakpoint response error
// This will probably consist of letting a user know that breakpoints failed to be set
@ -697,7 +697,7 @@ impl Session {
) -> Task<Result<Entity<Self>>> {
let (message_tx, mut message_rx) = futures::channel::mpsc::unbounded();
cx.spawn(move |mut cx| async move {
cx.spawn(async move |cx| {
let (mode, capabilities) = LocalMode::new(
session_id,
parent_session.clone(),
@ -710,31 +710,30 @@ impl Session {
.await?;
cx.new(|cx| {
let _background_tasks =
vec![cx.spawn(move |this: WeakEntity<Self>, mut cx| async move {
let mut initialized_tx = Some(initialized_tx);
while let Some(message) = message_rx.next().await {
if let Message::Event(event) = message {
if let Events::Initialized(_) = *event {
if let Some(tx) = initialized_tx.take() {
tx.send(()).ok();
}
} else {
let Ok(_) = this.update(&mut cx, |session, cx| {
session.handle_dap_event(event, cx);
}) else {
break;
};
let _background_tasks = vec![cx.spawn(async move |this: WeakEntity<Self>, cx| {
let mut initialized_tx = Some(initialized_tx);
while let Some(message) = message_rx.next().await {
if let Message::Event(event) = message {
if let Events::Initialized(_) = *event {
if let Some(tx) = initialized_tx.take() {
tx.send(()).ok();
}
} else {
let Ok(_) = start_debugging_requests_tx
.unbounded_send((session_id, message))
else {
let Ok(_) = this.update(cx, |session, cx| {
session.handle_dap_event(event, cx);
}) else {
break;
};
}
} else {
let Ok(_) =
start_debugging_requests_tx.unbounded_send((session_id, message))
else {
break;
};
}
})];
}
})];
cx.subscribe(&breakpoint_store, |this, _, event, cx| match event {
BreakpointStoreEvent::BreakpointsUpdated(path, reason) => {
@ -1102,17 +1101,17 @@ impl Session {
let error = Err(anyhow::Error::msg(
"Couldn't complete request because it's not supported",
));
return cx.spawn(|this, mut cx| async move {
this.update(&mut cx, |this, cx| process_result(this, error, cx))
return cx.spawn(async move |this, cx| {
this.update(cx, |this, cx| process_result(this, error, cx))
.log_err()
.flatten()
});
}
let request = mode.request_dap(session_id, request, cx);
cx.spawn(|this, mut cx| async move {
cx.spawn(async move |this, cx| {
let result = request.await;
this.update(&mut cx, |this, cx| process_result(this, result, cx))
this.update(cx, |this, cx| process_result(this, result, cx))
.log_err()
.flatten()
})