krisyotam/zed

crates/assistant/src/inline_assistant.rs+2−3

                     let executor = cx.background_executor().clone();
                     let message_id = message_id.clone();
                     let line_based_stream_diff: Task<anyhow::Result<()>> =
-                        cx.background_executor().spawn(async move {
+                        cx.background_spawn(async move {
                             let mut response_latency = None;
                             let request_start = Instant::now();
                             let diff = async {
         cx.spawn(|codegen, mut cx| async move {
             let (deleted_row_ranges, inserted_row_ranges) = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     let old_text = old_snapshot
                         .text_for_range(
                             Point::new(old_range.start.row, 0)

crates/assistant/src/terminal_inline_assistant.rs+1−1

@@ -1149,7 +1149,7 @@ impl Codegen { · 1148 unmodified lines
1149		1149
1150	let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);	1150	let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
1151		1151
1152	let task = cx.background_executor().spawn({	1152	let task = cx.background_spawn({
1153	let message_id = message_id.clone();	1153	let message_id = message_id.clone();
1154	let executor = cx.background_executor().clone();	1154	let executor = cx.background_executor().clone();
1155	async move {	1155	async move {

crates/assistant2/src/buffer_codegen.rs+2−3

                     let executor = cx.background_executor().clone();
                     let message_id = message_id.clone();
                     let line_based_stream_diff: Task<anyhow::Result<()>> =
-                        cx.background_executor().spawn(async move {
+                        cx.background_spawn(async move {
                             let mut response_latency = None;
                             let request_start = Instant::now();
                             let diff = async {
         cx.spawn(|codegen, mut cx| async move {
             let (deleted_row_ranges, inserted_row_ranges) = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     let old_text = old_snapshot
                         .text_for_range(
                             Point::new(old_range.start.row, 0)

crates/assistant2/src/context_picker/fetch_context_picker.rs+1−2

@@ -208,8 +208,7 @@ impl PickerDelegate for FetchContextPickerDelegate { · 207 unmodified lines
208	let confirm_behavior = self.confirm_behavior;	208	let confirm_behavior = self.confirm_behavior;
209	cx.spawn_in(window, \|this, mut cx\| async move {	209	cx.spawn_in(window, \|this, mut cx\| async move {
210	let text = cx	210	let text = cx
211	.background_executor()	211	.background_spawn(Self::build_message(http_client, url.clone()))
212	.spawn(Self::build_message(http_client, url.clone()))
213	.await?;	212	.await?;
214		213
215	this.update_in(&mut cx, \|this, window, cx\| {	214	this.update_in(&mut cx, \|this, window, cx\| {

crates/assistant2/src/context_picker/thread_context_picker.rs+1−1

@@ -123,7 +123,7 @@ impl PickerDelegate for ThreadContextPickerDelegate { · 122 unmodified lines
123	};	123	};
124		124
125	let executor = cx.background_executor().clone();	125	let executor = cx.background_executor().clone();
126	let search_task = cx.background_executor().spawn(async move {	126	let search_task = cx.background_spawn(async move {
127	if query.is_empty() {	127	if query.is_empty() {
128	threads	128	threads
129	} else {	129	} else {

crates/assistant2/src/context_store.rs+2−4

 use anyhow::{anyhow, bail, Result};
 use collections::{BTreeMap, HashMap, HashSet};
 use futures::{self, future, Future, FutureExt};
-use gpui::{App, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};
 use language::Buffer;
 use project::{ProjectPath, Worktree};
 use rope::Rope;
     };
     // Important to collect version at the same time as content so that staleness logic is correct.
     let content = buffer.as_rope().clone();
-    let text_task = cx
+    let text_task = cx.background_spawn(async move { to_fenced_codeblock(&path, content) });
-        .background_executor()
-        .spawn(async move { to_fenced_codeblock(&path, content) });
     (buffer_info, text_task)
 }

crates/assistant2/src/terminal_codegen.rs+2−2

@@ -1,7 +1,7 @@
1	use crate::inline_prompt_editor::CodegenStatus;	1	use crate::inline_prompt_editor::CodegenStatus;
2	use client::telemetry::Telemetry;	2	use client::telemetry::Telemetry;
3	use futures::{channel::mpsc, SinkExt, StreamExt};	3	use futures::{channel::mpsc, SinkExt, StreamExt};
4	use gpui::{App, Context, Entity, EventEmitter, Task};	4	use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
5	use language_model::{LanguageModelRegistry, LanguageModelRequest};	5	use language_model::{LanguageModelRegistry, LanguageModelRequest};
6	use language_models::report_assistant_event;	6	use language_models::report_assistant_event;
7	use std::{sync::Arc, time::Instant};	7	use std::{sync::Arc, time::Instant};
@@ -53,7 +53,7 @@ impl TerminalCodegen { · 45 unmodified lines
53		53
54	let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);	54	let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
55		55
56	let task = cx.background_executor().spawn({	56	let task = cx.background_spawn({
57	let message_id = message_id.clone();	57	let message_id = message_id.clone();
58	let executor = cx.background_executor().clone();	58	let executor = cx.background_executor().clone();
59	async move {	59	async move {

crates/assistant_context_editor/src/context.rs+1−1

@@ -849,7 +849,7 @@ impl AssistantContext { · 848 unmodified lines
849	.collect::<Vec<_>>();	849	.collect::<Vec<_>>();
850	context_ops.extend(self.pending_ops.iter().cloned());	850	context_ops.extend(self.pending_ops.iter().cloned());
851		851
852	cx.background_executor().spawn(async move {	852	cx.background_spawn(async move {
853	let buffer_ops = buffer_ops.await;	853	let buffer_ops = buffer_ops.await;
854	context_ops.sort_unstable_by_key(\|op\| op.timestamp());	854	context_ops.sort_unstable_by_key(\|op\| op.timestamp());
855	buffer_ops	855	buffer_ops

crates/assistant_context_editor/src/context_store.rs+16−19

                     local_versions.push(context.version(cx).to_proto(context_id.clone()));
                     let client = this.client.clone();
                     let project_id = envelope.payload.project_id;
-                    cx.background_executor()
+                    cx.background_spawn(async move {
-                        .spawn(async move {
+                        let operations = operations.await;
-                            let operations = operations.await;
+                        for operation in operations {
-                            for operation in operations {
+                            client.send(proto::UpdateContext {
-                                client.send(proto::UpdateContext {
+                                project_id,
-                                    project_id,
+                                context_id: context_id.to_proto(),
-                                    context_id: context_id.to_proto(),
+                                operation: Some(operation),
-                                    operation: Some(operation),
+                            })?;
-                                })?;
+                        }
-                            }
+                        anyhow::Ok(())
-                            anyhow::Ok(())
+                    })
-                        })
+                    .detach_and_log_err(cx);
-                        .detach_and_log_err(cx);
                 }
             }
                 )
             })?;
             let operations = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     context_proto
                         .operations
                         .into_iter()
         let languages = self.languages.clone();
         let project = self.project.clone();
         let telemetry = self.telemetry.clone();
-        let load = cx.background_executor().spawn({
+        let load = cx.background_spawn({
             let path = path.clone();
             async move {
                 let saved_context = fs.load(&path).await?;
                 )
             })?;
             let operations = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     context_proto
                         .operations
                         .into_iter()
     pub fn search(&self, query: String, cx: &App) -> Task<Vec<SavedContextMetadata>> {
         let metadata = self.contexts_metadata.clone();
         let executor = cx.background_executor().clone();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             if query.is_empty() {
                 metadata
             } else {

crates/assistant_context_editor/src/patch.rs+3−4

 use collections::HashMap;
 use editor::ProposedChangesEditor;
 use futures::{future, TryFutureExt as _};
-use gpui::{App, AsyncApp, Entity, SharedString};
+use gpui::{App, AppContext as _, AsyncApp, Entity, SharedString};
 use language::{AutoindentMode, Buffer, BufferSnapshot};
 use project::{Project, ProjectPath};
 use std::{cmp, ops::Range, path::Path, sync::Arc};
         let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
         let suggestion = cx
-            .background_executor()
+            .background_spawn(async move { kind.resolve(&snapshot) })
-            .spawn(async move { kind.resolve(&snapshot) })
             .await;
         Ok((buffer, suggestion))
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::{App, AppContext as _};
+    use gpui::App;
     use language::{
         language_settings::AllLanguageSettings, Language, LanguageConfig, LanguageMatcher,
     };

crates/assistant_context_editor/src/slash_command.rs+2−2

@@ -4,7 +4,7 @@ pub use assistant_slash_command::SlashCommand; · 3 unmodified lines
4	use assistant_slash_command::{AfterCompletion, SlashCommandLine, SlashCommandWorkingSet};	4	use assistant_slash_command::{AfterCompletion, SlashCommandLine, SlashCommandWorkingSet};
5	use editor::{CompletionProvider, Editor};	5	use editor::{CompletionProvider, Editor};
6	use fuzzy::{match_strings, StringMatchCandidate};	6	use fuzzy::{match_strings, StringMatchCandidate};
7	use gpui::{App, Context, Entity, Task, WeakEntity, Window};	7	use gpui::{App, AppContext as _, Context, Entity, Task, WeakEntity, Window};
8	use language::{Anchor, Buffer, CompletionDocumentation, LanguageServerId, ToPoint};	8	use language::{Anchor, Buffer, CompletionDocumentation, LanguageServerId, ToPoint};
9	use parking_lot::Mutex;	9	use parking_lot::Mutex;
10	use project::CompletionIntent;	10	use project::CompletionIntent;
@@ -162,7 +162,7 @@ impl SlashCommandCompletionProvider { · 151 unmodified lines
162	let editor = self.editor.clone();	162	let editor = self.editor.clone();
163	let workspace = self.workspace.clone();	163	let workspace = self.workspace.clone();
164	let arguments = arguments.to_vec();	164	let arguments = arguments.to_vec();
165	cx.background_executor().spawn(async move {	165	cx.background_spawn(async move {
166	Ok(completions	166	Ok(completions
167	.await?	167	.await?
168	.into_iter()	168	.into_iter()

crates/assistant_context_editor/src/slash_command_picker.rs+1−2

         let all_commands = self.all_commands.clone();
         cx.spawn_in(window, |this, mut cx| async move {
             let filtered_commands = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     if query.is_empty() {
                         all_commands
                     } else {

crates/assistant_slash_command/src/extension_slash_command.rs+2−2

@@ -103,7 +103,7 @@ impl SlashCommand for ExtensionSlashCommand { · 102 unmodified lines
103	) -> Task<Result<Vec<ArgumentCompletion>>> {	103	) -> Task<Result<Vec<ArgumentCompletion>>> {
104	let command = self.command.clone();	104	let command = self.command.clone();
105	let arguments = arguments.to_owned();	105	let arguments = arguments.to_owned();
106	cx.background_executor().spawn(async move {	106	cx.background_spawn(async move {
107	let completions = self	107	let completions = self
108	.extension	108	.extension
109	.complete_slash_command_argument(command, arguments)	109	.complete_slash_command_argument(command, arguments)
@@ -135,7 +135,7 @@ impl SlashCommand for ExtensionSlashCommand { · 25 unmodified lines
135	) -> Task<SlashCommandResult> {	135	) -> Task<SlashCommandResult> {
136	let command = self.command.clone();	136	let command = self.command.clone();
137	let arguments = arguments.to_owned();	137	let arguments = arguments.to_owned();
138	let output = cx.background_executor().spawn(async move {	138	let output = cx.background_spawn(async move {
139	let delegate =	139	let delegate =
140	delegate.map(\|delegate\| Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _);	140	delegate.map(\|delegate\| Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _);
141	let output = self	141	let output = self

crates/assistant_slash_commands/src/auto_command.rs+47−48

@@ -82,7 +82,7 @@ impl SlashCommand for AutoCommand { · 81 unmodified lines
82	project_index.flush_summary_backlogs(cx)	82	project_index.flush_summary_backlogs(cx)
83	})?;	83	})?;
84		84
85	cx.background_executor().spawn(task).await;	85	cx.background_spawn(task).await;
86		86
87	anyhow::Ok(Vec::new())	87	anyhow::Ok(Vec::new())
88	})	88	})
@@ -129,7 +129,7 @@ impl SlashCommand for AutoCommand { · 40 unmodified lines
129	// so you don't have to write it again.	129	// so you don't have to write it again.
130	let original_prompt = argument.to_string();	130	let original_prompt = argument.to_string();
131		131
132	cx.background_executor().spawn(async move {	132	cx.background_spawn(async move {
133	let commands = task.await?;	133	let commands = task.await?;
134	let mut prompt = String::new();	134	let mut prompt = String::new();
135		135
@@ -285,57 +285,56 @@ async fn commands_for_summaries( · 149 unmodified lines
285	})	285	})
286	.collect::<Vec<_>>();	286	.collect::<Vec<_>>();
287		287
288	cx.background_executor()	288	cx.background_spawn(async move {
289	.spawn(async move {	289	let futures = completion_streams
290	let futures = completion_streams	290	.into_iter()
291	.into_iter()	291	.enumerate()
292	.enumerate()	292	.map(\|(ix, (stream, tx))\| async move {
293	.map(\|(ix, (stream, tx))\| async move {	293	let start = std::time::Instant::now();
294	let start = std::time::Instant::now();	294	let events = stream.await?;
295	let events = stream.await?;	295	log::info!("Time taken for awaiting /await chunk stream #{ix}: {:?}", start.elapsed());
296	log::info!("Time taken for awaiting /await chunk stream #{ix}: {:?}", start.elapsed());	296
297		297	let completion: String = events
298	let completion: String = events	298	.filter_map(\|event\| async {
299	.filter_map(\|event\| async {	299	if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
300	if let Ok(LanguageModelCompletionEvent::Text(text)) = event {	300	Some(text)
301	Some(text)	301	} else {
302	} else {	302	None
303	None
304	}
305	})
306	.collect()
307	.await;
308
309	log::info!("Time taken for all /auto chunks to come back for #{ix}: {:?}", start.elapsed());
310
311	for line in completion.split('\n') {
312	if let Some(first_space) = line.find(' ') {
313	let command = &line[..first_space].trim();
314	let arg = &line[first_space..].trim();
315
316	tx.send(CommandToRun {
317	name: command.to_string(),
318	arg: arg.to_string(),
319	})
320	.await?;
321	} else if !line.trim().is_empty() {
322	// All slash-commands currently supported in context inference need a space for the argument.
323	log::warn!(
324	"Context inference returned a non-blank line that contained no spaces (meaning no argument for the slash command): {:?}",
325	line
326	);
327	}	303	}
		304	})
		305	.collect()
		306	.await;
		307
		308	log::info!("Time taken for all /auto chunks to come back for #{ix}: {:?}", start.elapsed());
		309
		310	for line in completion.split('\n') {
		311	if let Some(first_space) = line.find(' ') {
		312	let command = &line[..first_space].trim();
		313	let arg = &line[first_space..].trim();
		314
		315	tx.send(CommandToRun {
		316	name: command.to_string(),
		317	arg: arg.to_string(),
		318	})
		319	.await?;
		320	} else if !line.trim().is_empty() {
		321	// All slash-commands currently supported in context inference need a space for the argument.
		322	log::warn!(
		323	"Context inference returned a non-blank line that contained no spaces (meaning no argument for the slash command): {:?}",
		324	line
		325	);
328	}	326	}
		327	}
329		328
330	anyhow::Ok(())	329	anyhow::Ok(())
331	})	330	})
332	.collect::<Vec<_>>();	331	.collect::<Vec<_>>();
333		332
334	let _ = futures::future::try_join_all(futures).await.log_err();	333	let _ = futures::future::try_join_all(futures).await.log_err();
335		334
336	let duration = all_start.elapsed();	335	let duration = all_start.elapsed();
337	eprintln!("All futures completed in {:?}", duration);	336	eprintln!("All futures completed in {:?}", duration);
338	})	337	})
339	.await;	338	.await;
340		339
341	drop(tx); // Close the channel so that rx.collect() won't hang. This is safe because all futures have completed.	340	drop(tx); // Close the channel so that rx.collect() won't hang. This is safe because all futures have completed.

crates/assistant_slash_commands/src/cargo_workspace_command.rs+1−1

@@ -132,7 +132,7 @@ impl SlashCommand for CargoWorkspaceSlashCommand { · 131 unmodified lines
132	let project = workspace.project().clone();	132	let project = workspace.project().clone();
133	let fs = workspace.project().read(cx).fs().clone();	133	let fs = workspace.project().read(cx).fs().clone();
134	let path = Self::path_to_cargo_toml(project, cx);	134	let path = Self::path_to_cargo_toml(project, cx);
135	let output = cx.background_executor().spawn(async move {	135	let output = cx.background_spawn(async move {
136	let path = path.with_context(\|\| "Cargo.toml not found")?;	136	let path = path.with_context(\|\| "Cargo.toml not found")?;
137	Self::build_message(fs, &path).await	137	Self::build_message(fs, &path).await
138	});	138	});

crates/assistant_slash_commands/src/default_command.rs+1−1

@@ -54,7 +54,7 @@ impl SlashCommand for DefaultSlashCommand { · 53 unmodified lines
54	cx: &mut App,	54	cx: &mut App,
55	) -> Task<SlashCommandResult> {	55	) -> Task<SlashCommandResult> {
56	let store = PromptStore::global(cx);	56	let store = PromptStore::global(cx);
57	cx.background_executor().spawn(async move {	57	cx.background_spawn(async move {
58	let store = store.await?;	58	let store = store.await?;
59	let prompts = store.default_prompt_metadata();	59	let prompts = store.default_prompt_metadata();
60		60

crates/assistant_slash_commands/src/delta_command.rs+1−1

@@ -86,7 +86,7 @@ impl SlashCommand for DeltaSlashCommand { · 85 unmodified lines
86	}	86	}
87	}	87	}
88		88
89	cx.background_executor().spawn(async move {	89	cx.background_spawn(async move {
90	let mut output = SlashCommandOutput::default();	90	let mut output = SlashCommandOutput::default();
91	let mut changes_detected = false;	91	let mut changes_detected = false;
92		92

crates/assistant_slash_commands/src/diagnostics_command.rs+1−1

@@ -129,7 +129,7 @@ impl SlashCommand for DiagnosticsSlashCommand { · 128 unmodified lines
129		129
130	let paths = self.search_paths(query.clone(), cancellation_flag.clone(), &workspace, cx);	130	let paths = self.search_paths(query.clone(), cancellation_flag.clone(), &workspace, cx);
131	let executor = cx.background_executor().clone();	131	let executor = cx.background_executor().clone();
132	cx.background_executor().spawn(async move {	132	cx.background_spawn(async move {
133	let mut matches: Vec<String> = paths	133	let mut matches: Vec<String> = paths
134	.await	134	.await
135	.into_iter()	135	.into_iter()

crates/assistant_slash_commands/src/docs_command.rs+2−2

@@ -176,7 +176,7 @@ impl SlashCommand for DocsSlashCommand { · 175 unmodified lines
176	.provider()	176	.provider()
177	.ok_or_else(\|\| anyhow!("no docs provider specified"))	177	.ok_or_else(\|\| anyhow!("no docs provider specified"))
178	.and_then(\|provider\| IndexedDocsStore::try_global(provider, cx));	178	.and_then(\|provider\| IndexedDocsStore::try_global(provider, cx));
179	cx.background_executor().spawn(async move {	179	cx.background_spawn(async move {
180	fn build_completions(items: Vec<String>) -> Vec<ArgumentCompletion> {	180	fn build_completions(items: Vec<String>) -> Vec<ArgumentCompletion> {
181	items	181	items
182	.into_iter()	182	.into_iter()
@@ -284,7 +284,7 @@ impl SlashCommand for DocsSlashCommand { · 101 unmodified lines
284		284
285	let args = DocsSlashCommandArgs::parse(arguments);	285	let args = DocsSlashCommandArgs::parse(arguments);
286	let executor = cx.background_executor().clone();	286	let executor = cx.background_executor().clone();
287	let task = cx.background_executor().spawn({	287	let task = cx.background_spawn({
288	let store = args	288	let store = args
289	.provider()	289	.provider()
290	.ok_or_else(\|\| anyhow!("no docs provider specified"))	290	.ok_or_else(\|\| anyhow!("no docs provider specified"))

crates/assistant_slash_commands/src/fetch_command.rs+1−1

@@ -151,7 +151,7 @@ impl SlashCommand for FetchSlashCommand { · 150 unmodified lines
151	let http_client = workspace.read(cx).client().http_client();	151	let http_client = workspace.read(cx).client().http_client();
152	let url = argument.to_string();	152	let url = argument.to_string();
153		153
154	let text = cx.background_executor().spawn({	154	let text = cx.background_spawn({
155	let url = url.clone();	155	let url = url.clone();
156	async move { Self::build_message(http_client, &url).await }	156	async move { Self::build_message(http_client, &url).await }
157	});	157	});

crates/assistant_slash_commands/src/file_command.rs+1−1

@@ -156,7 +156,7 @@ impl SlashCommand for FileSlashCommand { · 155 unmodified lines
156	cx,	156	cx,
157	);	157	);
158	let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);	158	let comment_id = cx.theme().syntax().highlight_id("comment").map(HighlightId);
159	cx.background_executor().spawn(async move {	159	cx.background_spawn(async move {
160	Ok(paths	160	Ok(paths
161	.await	161	.await
162	.into_iter()	162	.into_iter()

crates/assistant_slash_commands/src/project_command.rs+39−40

@@ -130,49 +130,48 @@ impl SlashCommand for ProjectSlashCommand { · 129 unmodified lines
130		130
131	let results = SemanticDb::load_results(results, &fs, &cx).await?;	131	let results = SemanticDb::load_results(results, &fs, &cx).await?;
132		132
133	cx.background_executor()	133	cx.background_spawn(async move {
134	.spawn(async move {	134	let mut output = "Project context:\n".to_string();
135	let mut output = "Project context:\n".to_string();	135	let mut sections = Vec::new();
136	let mut sections = Vec::new();	136
137		137	for (ix, query) in search_queries.into_iter().enumerate() {
138	for (ix, query) in search_queries.into_iter().enumerate() {	138	let start_ix = output.len();
139	let start_ix = output.len();	139	writeln!(&mut output, "Results for {query}:").unwrap();
140	writeln!(&mut output, "Results for {query}:").unwrap();	140	let mut has_results = false;
141	let mut has_results = false;	141	for result in &results {
142	for result in &results {	142	if result.query_index == ix {
143	if result.query_index == ix {	143	add_search_result_section(result, &mut output, &mut sections);
144	add_search_result_section(result, &mut output, &mut sections);	144	has_results = true;
145	has_results = true;
146	}
147	}
148	if has_results {
149	sections.push(SlashCommandOutputSection {
150	range: start_ix..output.len(),
151	icon: IconName::MagnifyingGlass,
152	label: query.into(),
153	metadata: None,
154	});
155	output.push('\n');
156	} else {
157	output.truncate(start_ix);
158	}	145	}
159	}	146	}
160		147	if has_results {
161	sections.push(SlashCommandOutputSection {	148	sections.push(SlashCommandOutputSection {
162	range: 0..output.len(),	149	range: start_ix..output.len(),
163	icon: IconName::Book,	150	icon: IconName::MagnifyingGlass,
164	label: "Project context".into(),	151	label: query.into(),
165	metadata: None,	152	metadata: None,
166	});	153	});
167		154	output.push('\n');
168	Ok(SlashCommandOutput {	155	} else {
169	text: output,	156	output.truncate(start_ix);
170	sections,
171	run_commands_in_text: true,
172	}	157	}
173	.to_event_stream())	158	}
174	})	159
175	.await	160	sections.push(SlashCommandOutputSection {
		161	range: 0..output.len(),
		162	icon: IconName::Book,
		163	label: "Project context".into(),
		164	metadata: None,
		165	});
		166
		167	Ok(SlashCommandOutput {
		168	text: output,
		169	sections,
		170	run_commands_in_text: true,
		171	}
		172	.to_event_stream())
		173	})
		174	.await
176	})	175	})
177	}	176	}
178	}	177	}

crates/assistant_slash_commands/src/prompt_command.rs+2−2

@@ -43,7 +43,7 @@ impl SlashCommand for PromptSlashCommand { · 42 unmodified lines
43	) -> Task<Result<Vec<ArgumentCompletion>>> {	43	) -> Task<Result<Vec<ArgumentCompletion>>> {
44	let store = PromptStore::global(cx);	44	let store = PromptStore::global(cx);
45	let query = arguments.to_owned().join(" ");	45	let query = arguments.to_owned().join(" ");
46	cx.background_executor().spawn(async move {	46	cx.background_spawn(async move {
47	let prompts = store.await?.search(query).await;	47	let prompts = store.await?.search(query).await;
48	Ok(prompts	48	Ok(prompts
49	.into_iter()	49	.into_iter()
@@ -77,7 +77,7 @@ impl SlashCommand for PromptSlashCommand { · 27 unmodified lines
77		77
78	let store = PromptStore::global(cx);	78	let store = PromptStore::global(cx);
79	let title = SharedString::from(title.clone());	79	let title = SharedString::from(title.clone());
80	let prompt = cx.background_executor().spawn({	80	let prompt = cx.background_spawn({
81	let title = title.clone();	81	let title = title.clone();
82	async move {	82	async move {
83	let store = store.await?;	83	let store = store.await?;

crates/assistant_slash_commands/src/search_command.rs+1−2

@@ -119,8 +119,7 @@ impl SlashCommand for SearchSlashCommand { · 118 unmodified lines
119	let loaded_results = SemanticDb::load_results(results, &fs, &cx).await?;	119	let loaded_results = SemanticDb::load_results(results, &fs, &cx).await?;
120		120
121	let output = cx	121	let output = cx
122	.background_executor()	122	.background_spawn(async move {
123	.spawn(async move {
124	let mut text = format!("Search results for {query}:\n");	123	let mut text = format!("Search results for {query}:\n");
125	let mut sections = Vec::new();	124	let mut sections = Vec::new();
126	for loaded_result in &loaded_results {	125	for loaded_result in &loaded_results {

crates/assistant_slash_commands/src/streaming_example_command.rs+37−38

@@ -63,56 +63,55 @@ impl SlashCommand for StreamingExampleSlashCommand { · 62 unmodified lines
63	cx: &mut App,	63	cx: &mut App,
64	) -> Task<SlashCommandResult> {	64	) -> Task<SlashCommandResult> {
65	let (events_tx, events_rx) = mpsc::unbounded();	65	let (events_tx, events_rx) = mpsc::unbounded();
66	cx.background_executor()	66	cx.background_spawn(async move {
67	.spawn(async move {	67	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
68	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {	68	icon: IconName::FileRust,
69	icon: IconName::FileRust,	69	label: "Section 1".into(),
70	label: "Section 1".into(),	70	metadata: None,
71	metadata: None,	71	}))?;
72	}))?;	72	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
73	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(	73	SlashCommandContent::Text {
74	SlashCommandContent::Text {	74	text: "Hello".into(),
75	text: "Hello".into(),	75	run_commands_in_text: false,
76	run_commands_in_text: false,	76	},
77	},	77	)))?;
78	)))?;	78	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
79	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;	79
80		80	Timer::after(Duration::from_secs(1)).await;
		81
		82	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
		83	icon: IconName::FileRust,
		84	label: "Section 2".into(),
		85	metadata: None,
		86	}))?;
		87	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
		88	SlashCommandContent::Text {
		89	text: "World".into(),
		90	run_commands_in_text: false,
		91	},
		92	)))?;
		93	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
		94
		95	for n in 1..=10 {
81	Timer::after(Duration::from_secs(1)).await;	96	Timer::after(Duration::from_secs(1)).await;
82		97
83	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {	98	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
84	icon: IconName::FileRust,	99	icon: IconName::StarFilled,
85	label: "Section 2".into(),	100	label: format!("Section {n}").into(),
86	metadata: None,	101	metadata: None,
87	}))?;	102	}))?;
88	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(	103	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
89	SlashCommandContent::Text {	104	SlashCommandContent::Text {
90	text: "World".into(),	105	text: "lorem ipsum ".repeat(n).trim().into(),
91	run_commands_in_text: false,	106	run_commands_in_text: false,
92	},	107	},
93	)))?;	108	)))?;
94	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;	109	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
		110	}
95		111
96	for n in 1..=10 {	112	anyhow::Ok(())
97	Timer::after(Duration::from_secs(1)).await;	113	})
98		114	.detach_and_log_err(cx);
99	events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
100	icon: IconName::StarFilled,
101	label: format!("Section {n}").into(),
102	metadata: None,
103	}))?;
104	events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
105	SlashCommandContent::Text {
106	text: "lorem ipsum ".repeat(n).trim().into(),
107	run_commands_in_text: false,
108	},
109	)))?;
110	events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
111	}
112
113	anyhow::Ok(())
114	})
115	.detach_and_log_err(cx);
116		115
117	Task::ready(Ok(events_rx.boxed()))	116	Task::ready(Ok(events_rx.boxed()))
118	}	117	}

crates/assistant_slash_commands/src/symbols_command.rs+2−2

@@ -4,7 +4,7 @@ use assistant_slash_command::{ · 3 unmodified lines
4	SlashCommandResult,	4	SlashCommandResult,
5	};	5	};
6	use editor::Editor;	6	use editor::Editor;
7	use gpui::{Task, WeakEntity};	7	use gpui::{AppContext as _, Task, WeakEntity};
8	use language::{BufferSnapshot, LspAdapterDelegate};	8	use language::{BufferSnapshot, LspAdapterDelegate};
9	use std::sync::Arc;	9	use std::sync::Arc;
10	use std::{path::Path, sync::atomic::AtomicBool};	10	use std::{path::Path, sync::atomic::AtomicBool};
@@ -69,7 +69,7 @@ impl SlashCommand for OutlineSlashCommand { · 58 unmodified lines
69	let snapshot = buffer.read(cx).snapshot();	69	let snapshot = buffer.read(cx).snapshot();
70	let path = snapshot.resolve_file_path(cx, true);	70	let path = snapshot.resolve_file_path(cx, true);
71		71
72	cx.background_executor().spawn(async move {	72	cx.background_spawn(async move {
73	let outline = snapshot	73	let outline = snapshot
74	.outline(None)	74	.outline(None)
75	.context("no symbols for active tab")?;	75	.context("no symbols for active tab")?;

crates/assistant_slash_commands/src/tab_command.rs+65−66

             cx,
         );
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let mut output = SlashCommandOutput::default();
             for (full_path, buffer, _) in tab_items_search.await? {
                 append_buffer_to_output(&buffer, full_path.as_deref(), &mut output).log_err();
                 })??;
         let background_executor = cx.background_executor().clone();
-        cx.background_executor()
+        cx.background_spawn(async move {
-            .spawn(async move {
+            open_buffers.sort_by_key(|(_, _, timestamp)| *timestamp);
-                open_buffers.sort_by_key(|(_, _, timestamp)| *timestamp);
+            if empty_query
-                if empty_query
+                || queries
-                    || queries
+                    .iter()
-                        .iter()
+                    .any(|query| query == ALL_TABS_COMPLETION_ITEM)
-                        .any(|query| query == ALL_TABS_COMPLETION_ITEM)
+            {
-                {
+                return Ok(open_buffers);
-                    return Ok(open_buffers);
+            }
-                }
-                let matched_items = if strict_match {
-                    let match_candidates = open_buffers
-                        .iter()
-                        .enumerate()
-                        .filter_map(|(id, (full_path, ..))| {
-                            let path_string = full_path.as_deref()?.to_string_lossy().to_string();
-                            Some((id, path_string))
-                        })
-                        .fold(HashMap::default(), |mut candidates, (id, path_string)| {
-                            candidates
-                                .entry(path_string)
-                                .or_insert_with(Vec::new)
-                                .push(id);
-                            candidates
-                        });
-                    queries
+            let matched_items = if strict_match {
-                        .iter()
+                let match_candidates = open_buffers
-                        .filter_map(|query| match_candidates.get(query))
+                    .iter()
-                        .flatten()
+                    .enumerate()
-                        .copied()
+                    .filter_map(|(id, (full_path, ..))| {
-                        .filter_map(|id| open_buffers.get(id))
+                        let path_string = full_path.as_deref()?.to_string_lossy().to_string();
-                        .cloned()
+                        Some((id, path_string))
-                        .collect()
+                    })
-                } else {
+                    .fold(HashMap::default(), |mut candidates, (id, path_string)| {
-                    let match_candidates = open_buffers
+                        candidates
-                        .iter()
+                            .entry(path_string)
-                        .enumerate()
+                            .or_insert_with(Vec::new)
-                        .filter_map(|(id, (full_path, ..))| {
+                            .push(id);
-                            let path_string = full_path.as_deref()?.to_string_lossy().to_string();
+                        candidates
-                            Some(fuzzy::StringMatchCandidate::new(id, &path_string))
-                        })
-                        .collect::<Vec<_>>();
-                    let mut processed_matches = HashSet::default();
-                    let file_queries = queries.iter().map(|query| {
-                        fuzzy::match_strings(
-                            &match_candidates,
-                            query,
-                            true,
-                            usize::MAX,
-                            &cancel,
-                            background_executor.clone(),
-                        )
                     });
-                    join_all(file_queries)
+                queries
-                        .await
+                    .iter()
-                        .into_iter()
+                    .filter_map(|query| match_candidates.get(query))
-                        .flatten()
+                    .flatten()
-                        .filter(|string_match| processed_matches.insert(string_match.candidate_id))
+                    .copied()
-                        .filter_map(|string_match| open_buffers.get(string_match.candidate_id))
+                    .filter_map(|id| open_buffers.get(id))
-                        .cloned()
+                    .cloned()
-                        .collect()
+                    .collect()
-                };
+            } else {
-                Ok(matched_items)
+                let match_candidates = open_buffers
-            })
+                    .iter()
-            .await
+                    .enumerate()
+                    .filter_map(|(id, (full_path, ..))| {
+                        let path_string = full_path.as_deref()?.to_string_lossy().to_string();
+                        Some(fuzzy::StringMatchCandidate::new(id, &path_string))
+                    })
+                    .collect::<Vec<_>>();
+                let mut processed_matches = HashSet::default();
+                let file_queries = queries.iter().map(|query| {
+                    fuzzy::match_strings(
+                        &match_candidates,
+                        query,
+                        true,
+                        usize::MAX,
+                        &cancel,
+                        background_executor.clone(),
+                    )
+                });
+                join_all(file_queries)
+                    .await
+                    .into_iter()
+                    .flatten()
+                    .filter(|string_match| processed_matches.insert(string_match.candidate_id))
+                    .filter_map(|string_match| open_buffers.get(string_match.candidate_id))
+                    .cloned()
+                    .collect()
+            };
+            Ok(matched_items)
+        })
+        .await
     })
 }

crates/auto_update/src/auto_update.rs+2−2

@@ -513,7 +513,7 @@ impl AutoUpdater { · 512 unmodified lines
513	should_show: bool,	513	should_show: bool,
514	cx: &App,	514	cx: &App,
515	) -> Task<Result<()>> {	515	) -> Task<Result<()>> {
516	cx.background_executor().spawn(async move {	516	cx.background_spawn(async move {
517	if should_show {	517	if should_show {
518	KEY_VALUE_STORE	518	KEY_VALUE_STORE
519	.write_kvp(	519	.write_kvp(
@@ -531,7 +531,7 @@ impl AutoUpdater { · 11 unmodified lines
531	}	531	}
532		532
533	pub fn should_show_update_notification(&self, cx: &App) -> Task<Result<bool>> {	533	pub fn should_show_update_notification(&self, cx: &App) -> Task<Result<bool>> {
534	cx.background_executor().spawn(async move {	534	cx.background_spawn(async move {
535	Ok(KEY_VALUE_STORE	535	Ok(KEY_VALUE_STORE
536	.read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?	536	.read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?
537	.is_some())	537	.is_some())

crates/buffer_diff/src/buffer_diff.rs+5−7

 use futures::{channel::oneshot, future::OptionFuture};
 use git2::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
-use gpui::{App, AsyncApp, Context, Entity, EventEmitter};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter};
 use language::{Language, LanguageRegistry};
 use rope::Rope;
 use std::{cmp, future::Future, iter, ops::Range, sync::Arc};
                 cx,
             )
         });
-        let base_text_snapshot = cx
+        let base_text_snapshot = cx.background_spawn(OptionFuture::from(base_text_snapshot));
-            .background_executor()
-            .spawn(OptionFuture::from(base_text_snapshot));
-        let hunks = cx.background_executor().spawn({
+        let hunks = cx.background_spawn({
             let buffer = buffer.clone();
             async move { compute_hunks(diff_base, buffer) }
         });
                 .clone()
                 .map(|buffer| buffer.as_rope().clone()),
         );
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             BufferDiffInner {
                 hunks: compute_hunks(diff_base, buffer),
                 base_text: diff_base_buffer,
     use std::fmt::Write as _;
     use super::*;
-    use gpui::{AppContext as _, TestAppContext};
+    use gpui::TestAppContext;
     use rand::{rngs::StdRng, Rng as _};
     use text::{Buffer, BufferId, Rope};
     use unindent::Unindent as _;

crates/call/src/cross_platform/mod.rs+2−2

@@ -241,7 +241,7 @@ impl ActiveCall { · 240 unmodified lines
241	})	241	})
242	.shared();	242	.shared();
243	self.pending_room_creation = Some(room.clone());	243	self.pending_room_creation = Some(room.clone());
244	cx.background_executor().spawn(async move {	244	cx.background_spawn(async move {
245	room.await.map_err(\|err\| anyhow!("{:?}", err))?;	245	room.await.map_err(\|err\| anyhow!("{:?}", err))?;
246	anyhow::Ok(())	246	anyhow::Ok(())
247	})	247	})
@@ -278,7 +278,7 @@ impl ActiveCall { · 30 unmodified lines
278	};	278	};
279		279
280	let client = self.client.clone();	280	let client = self.client.clone();
281	cx.background_executor().spawn(async move {	281	cx.background_spawn(async move {
282	client	282	client
283	.request(proto::CancelCall {	283	.request(proto::CancelCall {
284	room_id,	284	room_id,

crates/call/src/cross_platform/room.rs+22−24

 use collections::{BTreeMap, HashMap, HashSet};
 use fs::Fs;
 use futures::{FutureExt, StreamExt};
-use gpui::{App, AppContext, AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity};
+use gpui::{App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity};
 use language::LanguageRegistry;
 #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 use livekit::{
     fn app_will_quit(&mut self, cx: &mut Context<Self>) -> impl Future<Output = ()> {
         let task = if self.status.is_online() {
             let leave = self.leave_internal(cx);
-            Some(cx.background_executor().spawn(async move {
+            Some(cx.background_spawn(async move {
                 leave.await.log_err();
             }))
         } else {
         self.clear_state(cx);
         let leave_room = self.client.request(proto::LeaveRoom {});
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             leave_room.await?;
             anyhow::Ok(())
         })
         };
         cx.notify();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             client
                 .request(proto::UpdateParticipantLocation {
                     room_id,
                 match publication {
                     Ok(publication) => {
                         if canceled {
-                            cx.background_executor()
+                            cx.background_spawn(async move {
-                                .spawn(async move {
+                                participant.unpublish_track(&publication.sid()).await
-                                    participant.unpublish_track(&publication.sid()).await
+                            })
-                                })
+                            .detach_and_log_err(cx)
-                                .detach_and_log_err(cx)
                         } else {
                             if live_kit.muted_by_user || live_kit.deafened {
                                 publication.mute();
                 match publication {
                     Ok(publication) => {
                         if canceled {
-                            cx.background_executor()
+                            cx.background_spawn(async move {
-                                .spawn(async move {
+                                participant.unpublish_track(&publication.sid()).await
-                                    participant.unpublish_track(&publication.sid()).await
+                            })
-                                })
+                            .detach()
-                                .detach()
                         } else {
                             live_kit.screen_track = LocalTrack::Published {
                                 track_publication: publication,
                 {
                     let local_participant = live_kit.room.local_participant();
                     let sid = track_publication.sid();
-                    cx.background_executor()
+                    cx.background_spawn(
-                        .spawn(async move { local_participant.unpublish_track(&sid).await })
+                        async move { local_participant.unpublish_track(&sid).await },
-                        .detach_and_log_err(cx);
+                    )
+                    .detach_and_log_err(cx);
                     cx.notify();
                 }
         }
         let participant = self.room.local_participant();
-        cx.background_executor()
+        cx.background_spawn(async move {
-            .spawn(async move {
+            for sid in tracks_to_unpublish {
-                for sid in tracks_to_unpublish {
+                participant.unpublish_track(&sid).await.log_err();
-                    participant.unpublish_track(&sid).await.log_err();
+            }
-                }
+        })
-            })
+        .detach();
-            .detach();
     }
 }

crates/call/src/macos/mod.rs+2−2

@@ -234,7 +234,7 @@ impl ActiveCall { · 233 unmodified lines
234	})	234	})
235	.shared();	235	.shared();
236	self.pending_room_creation = Some(room.clone());	236	self.pending_room_creation = Some(room.clone());
237	cx.background_executor().spawn(async move {	237	cx.background_spawn(async move {
238	room.await.map_err(\|err\| anyhow!("{:?}", err))?;	238	room.await.map_err(\|err\| anyhow!("{:?}", err))?;
239	anyhow::Ok(())	239	anyhow::Ok(())
240	})	240	})
@@ -271,7 +271,7 @@ impl ActiveCall { · 30 unmodified lines
271	};	271	};
272		272
273	let client = self.client.clone();	273	let client = self.client.clone();
274	cx.background_executor().spawn(async move {	274	cx.background_spawn(async move {
275	client	275	client
276	.request(proto::CancelCall {	276	.request(proto::CancelCall {
277	room_id,	277	room_id,

crates/call/src/macos/room.rs+4−6

     fn app_will_quit(&mut self, cx: &mut Context<Self>) -> impl Future<Output = ()> {
         let task = if self.status.is_online() {
             let leave = self.leave_internal(cx);
-            Some(cx.background_executor().spawn(async move {
+            Some(cx.background_spawn(async move {
                 leave.await.log_err();
             }))
         } else {
         self.clear_state(cx);
         let leave_room = self.client.request(proto::LeaveRoom {});
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             leave_room.await?;
             anyhow::Ok(())
         })
         };
         cx.notify();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             client
                 .request(proto::UpdateParticipantLocation {
                     room_id,
                                 live_kit.room.unpublish_track(publication);
                             } else {
                                 if live_kit.muted_by_user || live_kit.deafened {
-                                    cx.background_executor()
+                                    cx.background_spawn(publication.set_mute(true)).detach();
-                                        .spawn(publication.set_mute(true))
-                                        .detach();
                                 }
                                 live_kit.microphone_track = LocalTrack::Published {
                                     track_publication: publication,

crates/channel/src/channel_store.rs+14−18

@@ -514,8 +514,7 @@ impl ChannelStore { · 513 unmodified lines
514	}	514	}
515	}	515	}
516	};	516	};
517	cx.background_executor()	517	cx.background_spawn(async move { task.await.map_err(\|error\| anyhow!("{}", error)) })
518	.spawn(async move { task.await.map_err(\|error\| anyhow!("{}", error)) })
519	}	518	}
520		519
521	pub fn is_channel_admin(&self, channel_id: ChannelId) -> bool {	520	pub fn is_channel_admin(&self, channel_id: ChannelId) -> bool {
@@ -781,7 +780,7 @@ impl ChannelStore { · 259 unmodified lines
781	cx: &mut Context<Self>,	780	cx: &mut Context<Self>,
782	) -> Task<Result<()>> {	781	) -> Task<Result<()>> {
783	let client = self.client.clone();	782	let client = self.client.clone();
784	cx.background_executor().spawn(async move {	783	cx.background_spawn(async move {
785	client	784	client
786	.request(proto::RespondToChannelInvite {	785	.request(proto::RespondToChannelInvite {
787	channel_id: channel_id.0,	786	channel_id: channel_id.0,
@@ -975,21 +974,18 @@ impl ChannelStore { · 187 unmodified lines
975		974
976	if let Some(operations) = operations {	975	if let Some(operations) = operations {
977	let client = this.client.clone();	976	let client = this.client.clone();
978	cx.background_executor()	977	cx.background_spawn(async move {
979	.spawn(async move {	978	let operations = operations.await;
980	let operations = operations.await;	979	for chunk in language::proto::split_operations(operations) {
981	for chunk in	980	client
982	language::proto::split_operations(operations)	981	.send(proto::UpdateChannelBuffer {
983	{	982	channel_id: channel_id.0,
984	client	983	operations: chunk,
985	.send(proto::UpdateChannelBuffer {	984	})
986	channel_id: channel_id.0,	985	.ok();
987	operations: chunk,	986	}
988	})	987	})
989	.ok();	988	.detach();
990	}
991	})
992	.detach();
993	return true;	989	return true;
994	}	990	}
995	}	991	}

crates/client/src/client.rs+7−7

@@ -19,7 +19,7 @@ use futures::{ · 18 unmodified lines
19	channel::oneshot, future::BoxFuture, AsyncReadExt, FutureExt, SinkExt, Stream, StreamExt,	19	channel::oneshot, future::BoxFuture, AsyncReadExt, FutureExt, SinkExt, Stream, StreamExt,
20	TryFutureExt as _, TryStreamExt,	20	TryFutureExt as _, TryStreamExt,
21	};	21	};
22	use gpui::{actions, App, AsyncApp, Entity, Global, Task, WeakEntity};	22	use gpui::{actions, App, AppContext as _, AsyncApp, Entity, Global, Task, WeakEntity};
23	use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};	23	use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
24	use parking_lot::RwLock;	24	use parking_lot::RwLock;
25	use postage::watch;	25	use postage::watch;
@@ -1064,7 +1064,7 @@ impl Client { · 1038 unmodified lines
1064	let rpc_url = self.rpc_url(http, release_channel);	1064	let rpc_url = self.rpc_url(http, release_channel);
1065	let system_id = self.telemetry.system_id();	1065	let system_id = self.telemetry.system_id();
1066	let metrics_id = self.telemetry.metrics_id();	1066	let metrics_id = self.telemetry.metrics_id();
1067	cx.background_executor().spawn(async move {	1067	cx.background_spawn(async move {
1068	use HttpOrHttps::*;	1068	use HttpOrHttps::*;
1069		1069
1070	#[derive(Debug)]	1070	#[derive(Debug)]
@@ -1743,7 +1743,7 @@ mod tests { · 672 unmodified lines
1743	use crate::test::FakeServer;	1743	use crate::test::FakeServer;
1744		1744
1745	use clock::FakeSystemClock;	1745	use clock::FakeSystemClock;
1746	use gpui::{AppContext as _, BackgroundExecutor, TestAppContext};	1746	use gpui::{BackgroundExecutor, TestAppContext};
1747	use http_client::FakeHttpClient;	1747	use http_client::FakeHttpClient;
1748	use parking_lot::Mutex;	1748	use parking_lot::Mutex;
1749	use proto::TypedEnvelope;	1749	use proto::TypedEnvelope;
@@ -1806,7 +1806,7 @@ mod tests { · 56 unmodified lines
1806		1806
1807	// Time out when client tries to connect.	1807	// Time out when client tries to connect.
1808	client.override_authenticate(move \|cx\| {	1808	client.override_authenticate(move \|cx\| {
1809	cx.background_executor().spawn(async move {	1809	cx.background_spawn(async move {
1810	Ok(Credentials {	1810	Ok(Credentials {
1811	user_id,	1811	user_id,
1812	access_token: "token".into(),	1812	access_token: "token".into(),
@@ -1814,7 +1814,7 @@ mod tests { · 1 unmodified line
1814	})	1814	})
1815	});	1815	});
1816	client.override_establish_connection(\|_, cx\| {	1816	client.override_establish_connection(\|_, cx\| {
1817	cx.background_executor().spawn(async move {	1817	cx.background_spawn(async move {
1818	future::pending::<()>().await;	1818	future::pending::<()>().await;
1819	unreachable!()	1819	unreachable!()
1820	})	1820	})
@@ -1848,7 +1848,7 @@ mod tests { · 27 unmodified lines
1848	// Time out when re-establishing the connection.	1848	// Time out when re-establishing the connection.
1849	server.allow_connections();	1849	server.allow_connections();
1850	client.override_establish_connection(\|_, cx\| {	1850	client.override_establish_connection(\|_, cx\| {
1851	cx.background_executor().spawn(async move {	1851	cx.background_spawn(async move {
1852	future::pending::<()>().await;	1852	future::pending::<()>().await;
1853	unreachable!()	1853	unreachable!()
1854	})	1854	})
@@ -1887,7 +1887,7 @@ mod tests { · 32 unmodified lines
1887	move \|cx\| {	1887	move \|cx\| {
1888	let auth_count = auth_count.clone();	1888	let auth_count = auth_count.clone();
1889	let dropped_auth_count = dropped_auth_count.clone();	1889	let dropped_auth_count = dropped_auth_count.clone();
1890	cx.background_executor().spawn(async move {	1890	cx.background_spawn(async move {
1891	*auth_count.lock() += 1;	1891	*auth_count.lock() += 1;
1892	let _drop = util::defer(move \|\| *dropped_auth_count.lock() += 1);	1892	let _drop = util::defer(move \|\| *dropped_auth_count.lock() += 1);
1893	future::pending::<()>().await;	1893	future::pending::<()>().await;

crates/client/src/telemetry.rs+20−22

@@ -5,7 +5,7 @@ use anyhow::Result; · 4 unmodified lines
5	use clock::SystemClock;	5	use clock::SystemClock;
6	use futures::channel::mpsc;	6	use futures::channel::mpsc;
7	use futures::{Future, StreamExt};	7	use futures::{Future, StreamExt};
8	use gpui::{App, BackgroundExecutor, Task};	8	use gpui::{App, AppContext as _, BackgroundExecutor, Task};
9	use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};	9	use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};
10	use parking_lot::Mutex;	10	use parking_lot::Mutex;
11	use release_channel::ReleaseChannel;	11	use release_channel::ReleaseChannel;
@@ -219,18 +219,17 @@ impl Telemetry { · 207 unmodified lines
219	}));	219	}));
220	Self::log_file_path();	220	Self::log_file_path();
221		221
222	cx.background_executor()	222	cx.background_spawn({
223	.spawn({	223	let state = state.clone();
224	let state = state.clone();	224	let os_version = os_version();
225	let os_version = os_version();	225	state.lock().os_version = Some(os_version.clone());
226	state.lock().os_version = Some(os_version.clone());	226	async move {
227	async move {	227	if let Some(tempfile) = File::create(Self::log_file_path()).log_err() {
228	if let Some(tempfile) = File::create(Self::log_file_path()).log_err() {	228	state.lock().log_file = Some(tempfile);
229	state.lock().log_file = Some(tempfile);
230	}
231	}	229	}
232	})	230	}
233	.detach();	231	})
		232	.detach();
234		233
235	cx.observe_global::<SettingsStore>({	234	cx.observe_global::<SettingsStore>({
236	let state = state.clone();	235	let state = state.clone();
@@ -252,17 +251,16 @@ impl Telemetry { · 15 unmodified lines
252	let (tx, mut rx) = mpsc::unbounded();	251	let (tx, mut rx) = mpsc::unbounded();
253	::telemetry::init(tx);	252	::telemetry::init(tx);
254		253
255	cx.background_executor()	254	cx.background_spawn({
256	.spawn({	255	let this = Arc::downgrade(&this);
257	let this = Arc::downgrade(&this);	256	async move {
258	async move {	257	while let Some(event) = rx.next().await {
259	while let Some(event) = rx.next().await {	258	let Some(state) = this.upgrade() else { break };
260	let Some(state) = this.upgrade() else { break };	259	state.report_event(Event::Flexible(event))
261	state.report_event(Event::Flexible(event))
262	}
263	}	260	}
264	})	261	}
265	.detach();	262	})
		263	.detach();
266		264
267	// We should only ever have one instance of Telemetry, leak the subscription to keep it alive	265	// We should only ever have one instance of Telemetry, leak the subscription to keep it alive
268	// rather than store in TelemetryState, complicating spawn as subscriptions are not Send	266	// rather than store in TelemetryState, complicating spawn as subscriptions are not Send

crates/client/src/test.rs+1−1

@@ -85,7 +85,7 @@ impl FakeServer { · 84 unmodified lines
85	Connection::in_memory(cx.background_executor().clone());	85	Connection::in_memory(cx.background_executor().clone());
86	let (connection_id, io, incoming) =	86	let (connection_id, io, incoming) =
87	peer.add_test_connection(server_conn, cx.background_executor().clone());	87	peer.add_test_connection(server_conn, cx.background_executor().clone());
88	cx.background_executor().spawn(io).detach();	88	cx.background_spawn(io).detach();
89	{	89	{
90	let mut state = state.lock();	90	let mut state = state.lock();
91	state.connection_id = Some(connection_id);	91	state.connection_id = Some(connection_id);

crates/collab/src/tests/test_server.rs+11−12

@@ -244,18 +244,17 @@ impl TestServer { · 243 unmodified lines
244	.await	244	.await
245	.expect("retrieving user failed")	245	.expect("retrieving user failed")
246	.unwrap();	246	.unwrap();
247	cx.background_executor()	247	cx.background_spawn(server.handle_connection(
248	.spawn(server.handle_connection(	248	server_conn,
249	server_conn,	249	client_name,
250	client_name,	250	Principal::User(user),
251	Principal::User(user),	251	ZedVersion(SemanticVersion::new(1, 0, 0)),
252	ZedVersion(SemanticVersion::new(1, 0, 0)),	252	None,
253	None,	253	None,
254	None,	254	Some(connection_id_tx),
255	Some(connection_id_tx),	255	Executor::Deterministic(cx.background_executor().clone()),
256	Executor::Deterministic(cx.background_executor().clone()),	256	))
257	))	257	.detach();
258	.detach();
259	let connection_id = connection_id_rx.await.map_err(\|e\| {	258	let connection_id = connection_id_rx.await.map_err(\|e\| {
260	EstablishConnectionError::Other(anyhow!(	259	EstablishConnectionError::Other(anyhow!(
261	"{} (is server shutting down?)",	260	"{} (is server shutting down?)",

crates/collab_ui/src/chat_panel.rs+2−3

     ) -> Task<Result<Entity<Self>>> {
         cx.spawn(|mut cx| async move {
             let serialized_panel = if let Some(panel) = cx
-                .background_executor()
+                .background_spawn(async move { KEY_VALUE_STORE.read_kvp(CHAT_PANEL_KEY) })
-                .spawn(async move { KEY_VALUE_STORE.read_kvp(CHAT_PANEL_KEY) })
                 .await
                 .log_err()
                 .flatten()
     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(

crates/collab_ui/src/chat_panel/message_editor.rs+1−2

         mut cx: AsyncWindowContext,
     ) {
         let (buffer, ranges) = cx
-            .background_executor()
+            .background_spawn(async move {
-            .spawn(async move {
                 let ranges = MENTIONS_SEARCH.search(&buffer, None).await;
                 (buffer, ranges)
             })

crates/collab_ui/src/collab_panel.rs+2−3

         mut cx: AsyncWindowContext,
     ) -> anyhow::Result<Entity<Self>> {
         let serialized_panel = cx
-            .background_executor()
+            .background_spawn(async move { KEY_VALUE_STORE.read_kvp(COLLABORATION_PANEL_KEY) })
-            .spawn(async move { KEY_VALUE_STORE.read_kvp(COLLABORATION_PANEL_KEY) })
             .await
             .map_err(|_| anyhow::anyhow!("Failed to read collaboration panel from key value store"))
             .log_err()
     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
         let collapsed_channels = self.collapsed_channels.clone();
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(

crates/collab_ui/src/notification_panel.rs+2−3

     ) -> Task<Result<Entity<Self>>> {
         cx.spawn(|mut cx| async move {
             let serialized_panel = if let Some(panel) = cx
-                .background_executor()
+                .background_spawn(async move { KEY_VALUE_STORE.read_kvp(NOTIFICATION_PANEL_KEY) })
-                .spawn(async move { KEY_VALUE_STORE.read_kvp(NOTIFICATION_PANEL_KEY) })
                 .await
                 .log_err()
                 .flatten()
     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(

crates/command_palette/src/command_palette.rs+1−1

@@ -281,7 +281,7 @@ impl PickerDelegate for CommandPaletteDelegate { · 280 unmodified lines
281	query = alias.to_string();	281	query = alias.to_string();
282	}	282	}
283	let (mut tx, mut rx) = postage::dispatch::channel(1);	283	let (mut tx, mut rx) = postage::dispatch::channel(1);
284	let task = cx.background_executor().spawn({	284	let task = cx.background_spawn({
285	let mut commands = self.all_commands.clone();	285	let mut commands = self.all_commands.clone();
286	let hit_counts = cx.global::<HitCounts>().clone();	286	let hit_counts = cx.global::<HitCounts>().clone();
287	let executor = cx.background_executor().clone();	287	let executor = cx.background_executor().clone();

crates/context_server/src/client.rs+2−2

@@ -1,7 +1,7 @@
1	use anyhow::{anyhow, Context as _, Result};	1	use anyhow::{anyhow, Context as _, Result};
2	use collections::HashMap;	2	use collections::HashMap;
3	use futures::{channel::oneshot, io::BufWriter, select, AsyncRead, AsyncWrite, FutureExt};	3	use futures::{channel::oneshot, io::BufWriter, select, AsyncRead, AsyncWrite, FutureExt};
4	use gpui::{AsyncApp, BackgroundExecutor, Task};	4	use gpui::{AppContext as _, AsyncApp, BackgroundExecutor, Task};
5	use parking_lot::Mutex;	5	use parking_lot::Mutex;
6	use postage::barrier;	6	use postage::barrier;
7	use serde::{de::DeserializeOwned, Deserialize, Serialize};	7	use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -192,7 +192,7 @@ impl Client { · 184 unmodified lines
192	let (stdout, stderr) = futures::join!(stdout_input_task, stderr_input_task);	192	let (stdout, stderr) = futures::join!(stdout_input_task, stderr_input_task);
193	stdout.or(stderr)	193	stdout.or(stderr)
194	});	194	});
195	let output_task = cx.background_executor().spawn({	195	let output_task = cx.background_spawn({
196	Self::handle_output(	196	Self::handle_output(
197	stdin,	197	stdin,
198	outbound_rx,	198	outbound_rx,

crates/copilot/src/copilot.rs+7−9

                 let new_snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot()).ok()?;
                 let content_changes = cx
-                    .background_executor()
+                    .background_spawn({
-                    .spawn({
                         let new_snapshot = new_snapshot.clone();
                         async move {
                             new_snapshot
                 }
             };
-            cx.background_executor()
+            cx.background_spawn(task.map_err(|err| anyhow!("{:?}", err)))
-                .spawn(task.map_err(|err| anyhow!("{:?}", err)))
         } else {
             // If we're downloading, wait until download is finished
             // If we're in a stuck state, display to the user
         self.update_sign_in_status(request::SignInStatus::NotSignedIn, cx);
         if let CopilotServer::Running(RunningCopilotServer { lsp: server, .. }) = &self.server {
             let server = server.clone();
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 server
                     .request::<request::SignOut>(request::SignOutParams {})
                     .await?;
         cx.notify();
-        cx.background_executor().spawn(start_task)
+        cx.background_spawn(start_task)
     }
     pub fn language_server(&self) -> Option<&Arc<LanguageServer>> {
                 .request::<request::NotifyAccepted>(request::NotifyAcceptedParams {
                     uuid: completion.uuid.clone(),
                 });
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             request.await?;
             Ok(())
         })
                         .map(|completion| completion.uuid.clone())
                         .collect(),
                 });
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             request.await?;
             Ok(())
         })
             .map(|file| file.path().to_path_buf())
             .unwrap_or_default();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let (version, snapshot) = snapshot.await?;
             let result = lsp
                 .request::<R>(request::GetCompletionsParams {

crates/db/src/db.rs+2−3

 // Re-export
 pub use anyhow;
 use anyhow::Context as _;
-use gpui::App;
+use gpui::{App, AppContext};
 pub use indoc::indoc;
 pub use paths::database_dir;
 pub use smol;
 where
     F: Future<Output = anyhow::Result<()>> + Send,
 {
-    cx.background_executor()
+    cx.background_spawn(async move { db_write().await.log_err() })
-        .spawn(async move { db_write().await.log_err() })
         .detach()
 }

crates/editor/src/display_map/wrap_map.rs+2−2

crates/editor/src/editor.rs+10−11

             let Some(matches_task) = editor
                 .read_with(&mut cx, |editor, cx| {
                     let buffer = editor.buffer().read(cx).snapshot(cx);
-                    cx.background_executor().spawn(async move {
+                    cx.background_spawn(async move {
                         let mut ranges = Vec::new();
                         let buffer_ranges =
                             vec![buffer.anchor_before(0)..buffer.anchor_after(buffer.len())];
                 return;
             }
             let new_rows =
-                cx.background_executor()
+                cx.background_spawn({
-                    .spawn({
+                    let snapshot = display_snapshot.clone();
-                        let snapshot = display_snapshot.clone();
+                    async move {
-                        async move {
+                        Self::fetch_runnable_ranges(&snapshot, Anchor::min()..Anchor::max())
-                            Self::fetch_runnable_ranges(&snapshot, Anchor::min()..Anchor::max())
+                    }
-                        }
+                })
-                    })
                     .await;
             let rows = Self::runnable_rows(project, display_snapshot, new_rows, cx.clone());
                 HoverLink::InlayHint(lsp_location, server_id) => {
                     let computation =
                         self.compute_target_location(lsp_location, server_id, window, cx);
-                    cx.background_executor().spawn(async move {
+                    cx.background_spawn(async move {
                         let location = computation.await?;
                         Ok(TargetTaskResult::Location(location))
                     })
     let scope = language.map(|language| language.default_scope());
     let executor = cx.background_executor().clone();
-    cx.background_executor().spawn(async move {
+    cx.background_spawn(async move {
         let classifier = CharClassifier::new(scope).for_completion(true);
         let mut last_word = chars
             .chars()
         self.update(cx, |project, cx| {
             let snippets = snippet_completions(project, buffer, buffer_position, cx);
             let project_completions = project.completions(buffer, buffer_position, options, cx);
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 let mut completions = project_completions.await?;
                 let snippets_completions = snippets.await?;
                 completions.extend(snippets_completions);

crates/editor/src/element.rs+1−2

                 Some(cx.spawn_in(window, |editor, mut cx| async move {
                     let scrollbar_size = scrollbar_layout.hitbox.size;
                     let scrollbar_markers = cx
-                        .background_executor()
+                        .background_spawn(async move {
-                        .spawn(async move {
                             let max_point = snapshot.display_snapshot.buffer_snapshot.max_point();
                             let mut marker_quads = Vec::new();
                             if scrollbar_settings.git_diff {

crates/editor/src/git/blame.rs+3−4

     blame::{Blame, BlameEntry},
     parse_git_remote_url, GitHostingProvider, GitHostingProviderRegistry, Oid,
 };
-use gpui::{App, Context, Entity, Subscription, Task};
+use gpui::{App, AppContext as _, Context, Entity, Subscription, Task};
 use http_client::HttpClient;
 use language::{markdown, Bias, Buffer, BufferSnapshot, Edit, LanguageRegistry, ParsedMarkdown};
 use multi_buffer::RowInfo;
         self.task = cx.spawn(|this, mut cx| async move {
             let result = cx
-                .background_executor()
+                .background_spawn({
-                .spawn({
                     let snapshot = snapshot.clone();
                     async move {
                         let Some(Blame {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::{AppContext as _, Context};
+    use gpui::Context;
     use language::{Point, Rope};
     use project::FakeFs;
     use rand::prelude::*;

crates/editor/src/hunk_diff.rs+5−6

 use collections::{HashMap, HashSet};
 use git::diff::DiffHunkStatus;
 use gpui::{
-    Action, AppContext, Corner, CursorStyle, Focusable as _, Hsla, Model, MouseButton,
+    Action, AppContext as _, Corner, CursorStyle, Focusable as _, Hsla, Model, MouseButton,
     Subscription, Task,
 };
 use language::{Buffer, BufferId, Point};
         self.diff_map
             .hunk_update_tasks
-            .insert(None, cx.background_executor().spawn(new_toggle_task));
+            .insert(None, cx.background_spawn(new_toggle_task));
     }
     pub(super) fn expand_diff_hunk(
                 .ok();
         });
-        diff_map.hunk_update_tasks.insert(
+        diff_map
-            Some(buffer_id),
+            .hunk_update_tasks
-            cx.background_executor().spawn(new_sync_task),
+            .insert(Some(buffer_id), cx.background_spawn(new_sync_task));
-        );
     }
     fn go_to_subsequent_hunk(

crates/editor/src/indent_guides.rs+3−5

 use std::{ops::Range, time::Duration};
 use collections::HashSet;
-use gpui::{App, Context, Task, Window};
+use gpui::{App, AppContext as _, Context, Task, Window};
 use language::language_settings::language_settings;
 use multi_buffer::{IndentGuide, MultiBufferRow};
 use text::{LineIndent, Point};
             let snapshot = snapshot.clone();
-            let task = cx
+            let task = cx.background_spawn(resolve_indented_range(snapshot, cursor_row));
-                .background_executor()
-                .spawn(resolve_indented_range(snapshot, cursor_row));
             // Try to resolve the indent in a short amount of time, otherwise move it to a background task.
             match cx
                 Err(future) => {
                     state.pending_refresh =
                         Some(cx.spawn_in(window, |editor, mut cx| async move {
-                            let result = cx.background_executor().spawn(future).await;
+                            let result = cx.background_spawn(future).await;
                             editor
                                 .update(&mut cx, |editor, _| {
                                     editor.active_indent_guides_state.active_indent_range = result;

crates/editor/src/inlay_hint_cache.rs+12−14

@@ -19,7 +19,7 @@ use crate::{ · 18 unmodified lines
19	use anyhow::Context as _;	19	use anyhow::Context as _;
20	use clock::Global;	20	use clock::Global;
21	use futures::future;	21	use futures::future;
22	use gpui::{AsyncApp, Context, Entity, Task, Window};	22	use gpui::{AppContext as _, AsyncApp, Context, Entity, Task, Window};
23	use language::{language_settings::InlayHintKind, Buffer, BufferSnapshot};	23	use language::{language_settings::InlayHintKind, Buffer, BufferSnapshot};
24	use parking_lot::RwLock;	24	use parking_lot::RwLock;
25	use project::{InlayHint, ResolveState};	25	use project::{InlayHint, ResolveState};
@@ -996,19 +996,17 @@ fn fetch_and_update_hints( · 970 unmodified lines
996		996
997	let background_task_buffer_snapshot = buffer_snapshot.clone();	997	let background_task_buffer_snapshot = buffer_snapshot.clone();
998	let background_fetch_range = fetch_range.clone();	998	let background_fetch_range = fetch_range.clone();
999	let new_update = cx	999	let new_update = cx.background_spawn(async move {
1000	.background_executor()	1000	calculate_hint_updates(
1001	.spawn(async move {	1001	query.excerpt_id,
1002	calculate_hint_updates(	1002	invalidate,
1003	query.excerpt_id,	1003	background_fetch_range,
1004	invalidate,	1004	new_hints,
1005	background_fetch_range,	1005	&background_task_buffer_snapshot,
1006	new_hints,	1006	cached_excerpt_hints,
1007	&background_task_buffer_snapshot,	1007	&visible_hints,
1008	cached_excerpt_hints,	1008	)
1009	&visible_hints,	1009	})
1010	)
1011	})
1012	.await;	1010	.await;
1013	if let Some(new_update) = new_update {	1011	if let Some(new_update) = new_update {
1014	log::debug!(	1012	log::debug!(

crates/editor/src/items.rs+21−22

@@ -1225,28 +1225,27 @@ impl SerializableItem for Editor { · 1224 unmodified lines
1225	let snapshot = buffer.read(cx).snapshot();	1225	let snapshot = buffer.read(cx).snapshot();
1226		1226
1227	Some(cx.spawn_in(window, \|_this, cx\| async move {	1227	Some(cx.spawn_in(window, \|_this, cx\| async move {
1228	cx.background_executor()	1228	cx.background_spawn(async move {
1229	.spawn(async move {	1229	let (contents, language) = if serialize_dirty_buffers && is_dirty {
1230	let (contents, language) = if serialize_dirty_buffers && is_dirty {	1230	let contents = snapshot.text();
1231	let contents = snapshot.text();	1231	let language = snapshot.language().map(\|lang\| lang.name().to_string());
1232	let language = snapshot.language().map(\|lang\| lang.name().to_string());	1232	(Some(contents), language)
1233	(Some(contents), language)	1233	} else {
1234	} else {	1234	(None, None)
1235	(None, None)	1235	};
1236	};
1237		1236
1238	let editor = SerializedEditor {	1237	let editor = SerializedEditor {
1239	abs_path,	1238	abs_path,
1240	contents,	1239	contents,
1241	language,	1240	language,
1242	mtime,	1241	mtime,
1243	};	1242	};
1244	DB.save_serialized_editor(item_id, workspace_id, editor)	1243	DB.save_serialized_editor(item_id, workspace_id, editor)
1245	.await	1244	.await
1246	.context("failed to save serialized editor")	1245	.context("failed to save serialized editor")
1247	})	1246	})
1248	.await	1247	.await
1249	.context("failed to save contents of buffer")?;	1248	.context("failed to save contents of buffer")?;
1250		1249
1251	Ok(())	1250	Ok(())
1252	}))	1251	}))
@@ -1540,7 +1539,7 @@ impl SearchableItem for Editor { · 287 unmodified lines
1540	ranges.iter().cloned().collect::<Vec<_>>()	1539	ranges.iter().cloned().collect::<Vec<_>>()
1541	});	1540	});
1542		1541
1543	cx.background_executor().spawn(async move {	1542	cx.background_spawn(async move {
1544	let mut ranges = Vec::new();	1543	let mut ranges = Vec::new();
1545		1544
1546	let search_within_ranges = if search_within_ranges.is_empty() {	1545	let search_within_ranges = if search_within_ranges.is_empty() {

crates/editor/src/tasks.rs+2−3

 use crate::Editor;
-use gpui::{App, Task as AsyncTask, Window};
+use gpui::{App, AppContext as _, Task as AsyncTask, Window};
 use project::Location;
 use task::{TaskContext, TaskVariables, VariableName};
 use text::{ToOffset, ToPoint};
     };
     editor.update(cx, |editor, cx| {
         let context_task = task_context_with_editor(editor, window, cx);
-        cx.background_executor()
+        cx.background_spawn(async move { context_task.await.unwrap_or_default() })
-            .spawn(async move { context_task.await.unwrap_or_default() })
     })
 }

crates/extension_host/src/extension_host.rs+40−46

                 load_initial_extensions.await;
                 let mut index_changed = false;
-                let mut debounce_timer = cx
+                let mut debounce_timer = cx.background_spawn(futures::future::pending()).fuse();
-                    .background_executor()
-                    .spawn(futures::future::pending())
-                    .fuse();
                 loop {
                     select_biased! {
                         _ = debounce_timer => {
         // Watch the installed extensions directory for changes. Whenever changes are
         // detected, rebuild the extension index, and load/unload any extensions that
         // have been added, removed, or modified.
-        this.tasks.push(cx.background_executor().spawn({
+        this.tasks.push(cx.background_spawn({
             let fs = this.fs.clone();
             let reload_tx = this.reload_tx.clone();
             let installed_dir = this.installed_dir.clone();
                 }
             });
-            cx.background_executor()
+            cx.background_spawn({
-                .spawn({
+                let extension_source_path = extension_source_path.clone();
-                    let extension_source_path = extension_source_path.clone();
+                async move {
-                    async move {
+                    builder
-                        builder
+                        .compile_extension(
-                            .compile_extension(
+                            &extension_source_path,
-                                &extension_source_path,
+                            &mut extension_manifest,
-                                &mut extension_manifest,
+                            CompileExtensionOptions { release: false },
-                                CompileExtensionOptions { release: false },
+                        )
-                            )
+                        .await
-                            .await
+                }
-                    }
+            })
-                })
+            .await?;
-                .await?;
             let output_path = &extensions_dir.join(extension_id.as_ref());
             if let Some(metadata) = fs.metadata(output_path).await? {
         };
         cx.notify();
-        let compile = cx.background_executor().spawn(async move {
+        let compile = cx.background_spawn(async move {
             let mut manifest = ExtensionManifest::load(fs, &path).await?;
             builder
                 .compile_extension(
         cx.emit(Event::ExtensionsUpdated);
         cx.spawn(|this, mut cx| async move {
-            cx.background_executor()
+            cx.background_spawn({
-                .spawn({
+                let fs = fs.clone();
-                    let fs = fs.clone();
+                async move {
-                    async move {
+                    for theme_path in themes_to_add.into_iter() {
-                        for theme_path in themes_to_add.into_iter() {
+                        proxy
-                            proxy
+                            .load_user_theme(theme_path, fs.clone())
-                                .load_user_theme(theme_path, fs.clone())
+                            .await
-                                .await
+                            .log_err();
-                                .log_err();
+                    }
-                        }
-                        for (icon_theme_path, icons_root_path) in icon_themes_to_add.into_iter() {
+                    for (icon_theme_path, icons_root_path) in icon_themes_to_add.into_iter() {
+                        proxy
+                            .load_icon_theme(icon_theme_path, icons_root_path, fs.clone())
+                            .await
+                            .log_err();
+                    }
+                    for snippets_path in &snippets_to_add {
+                        if let Some(snippets_contents) = fs.load(snippets_path).await.log_err() {
                             proxy
-                                .load_icon_theme(icon_theme_path, icons_root_path, fs.clone())
+                                .register_snippet(snippets_path, &snippets_contents)
-                                .await
                                 .log_err();
                         }
-                        for snippets_path in &snippets_to_add {
-                            if let Some(snippets_contents) = fs.load(snippets_path).await.log_err()
-                            {
-                                proxy
-                                    .register_snippet(snippets_path, &snippets_contents)
-                                    .log_err();
-                            }
-                        }
                     }
-                })
+                }
-                .await;
+            })
+            .await;
             let mut wasm_extensions = Vec::new();
             for extension in extension_entries {
         let extensions_dir = self.installed_dir.clone();
         let index_path = self.index_path.clone();
         let proxy = self.proxy.clone();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let start_time = Instant::now();
             let mut index = ExtensionIndex::default();
             return Task::ready(Err(anyhow!("extension no longer installed")));
         };
         let fs = self.fs.clone();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             const EXTENSION_TOML: &str = "extension.toml";
             const EXTENSION_WASM: &str = "extension.wasm";
             const CONFIG_TOML: &str = "config.toml";

crates/feedback/src/system_specs.rs+2−2

@@ -1,5 +1,5 @@
1	use client::telemetry;	1	use client::telemetry;
2	use gpui::{App, Task, Window};	2	use gpui::{App, AppContext as _, Task, Window};
3	use human_bytes::human_bytes;	3	use human_bytes::human_bytes;
4	use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};	4	use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
5	use serde::Serialize;	5	use serde::Serialize;
@@ -44,7 +44,7 @@ impl SystemSpecs { · 38 unmodified lines
44	None	44	None
45	};	45	};
46		46
47	cx.background_executor().spawn(async move {	47	cx.background_spawn(async move {
48	let os_version = telemetry::os_version();	48	let os_version = telemetry::os_version();
49	SystemSpecs {	49	SystemSpecs {
50	app_version,	50	app_version,

crates/file_finder/src/file_finder.rs+1−1

@@ -127,7 +127,7 @@ impl FileFinder { · 126 unmodified lines
127	let abs_path = abs_path?;	127	let abs_path = abs_path?;
128	if project.is_local() {	128	if project.is_local() {
129	let fs = fs.clone();	129	let fs = fs.clone();
130	Some(cx.background_executor().spawn(async move {	130	Some(cx.background_spawn(async move {
131	if fs.is_file(&abs_path).await {	131	if fs.is_file(&abs_path).await {
132	Some(FoundPath::new(project_path, Some(abs_path)))	132	Some(FoundPath::new(project_path, Some(abs_path)))
133	} else {	133	} else {

crates/git_ui/src/git_panel.rs+2−3

     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(
         let task = if self.has_staged_changes() {
             // Repository serializes all git operations, so we can just send a commit immediately
             let commit_task = active_repository.read(cx).commit(message.into(), None);
-            cx.background_executor()
+            cx.background_spawn(async move { commit_task.await? })
-                .spawn(async move { commit_task.await? })
         } else {
             let changed_files = self
                 .entries

crates/git_ui/src/project_diff.rs+1−1

@@ -7,7 +7,7 @@ use editor::{scroll::Autoscroll, Editor, EditorEvent, ToPoint}; · 6 unmodified lines
7	use feature_flags::FeatureFlagViewExt;	7	use feature_flags::FeatureFlagViewExt;
8	use futures::StreamExt;	8	use futures::StreamExt;
9	use gpui::{	9	use gpui::{
10	actions, AnyElement, AnyView, App, AppContext, AsyncWindowContext, Entity, EventEmitter,	10	actions, AnyElement, AnyView, App, AppContext as _, AsyncWindowContext, Entity, EventEmitter,
11	FocusHandle, Focusable, Render, Subscription, Task, WeakEntity,	11	FocusHandle, Focusable, Render, Subscription, Task, WeakEntity,
12	};	12	};
13	use language::{Anchor, Buffer, Capability, OffsetRangeExt, Point};	13	use language::{Anchor, Buffer, Capability, OffsetRangeExt, Point};

crates/git_ui/src/repository_selector.rs+1−2

@@ -177,8 +177,7 @@ impl PickerDelegate for RepositorySelectorDelegate { · 176 unmodified lines
177		177
178	cx.spawn_in(window, \|this, mut cx\| async move {	178	cx.spawn_in(window, \|this, mut cx\| async move {
179	let filtered_repositories = cx	179	let filtered_repositories = cx
180	.background_executor()	180	.background_spawn(async move {
181	.spawn(async move {
182	if query.is_empty() {	181	if query.is_empty() {
183	all_repositories	182	all_repositories
184	} else {	183	} else {

crates/image_viewer/src/image_viewer.rs+1−1

@@ -252,7 +252,7 @@ impl SerializableItem for ImageView { · 251 unmodified lines
252	let workspace_id = workspace.database_id()?;	252	let workspace_id = workspace.database_id()?;
253	let image_path = self.image_item.read(cx).file.as_local()?.abs_path(cx);	253	let image_path = self.image_item.read(cx).file.as_local()?.abs_path(cx);
254		254
255	Some(cx.background_executor().spawn({	255	Some(cx.background_spawn({
256	async move {	256	async move {
257	IMAGE_VIEWER	257	IMAGE_VIEWER
258	.save_image_path(item_id, workspace_id, image_path)	258	.save_image_path(item_id, workspace_id, image_path)

crates/journal/src/journal.rs+2−2

@@ -2,7 +2,7 @@ use anyhow::Result; · 1 unmodified line
2	use chrono::{Datelike, Local, NaiveTime, Timelike};	2	use chrono::{Datelike, Local, NaiveTime, Timelike};
3	use editor::scroll::Autoscroll;	3	use editor::scroll::Autoscroll;
4	use editor::Editor;	4	use editor::Editor;
5	use gpui::{actions, App, Context, Window};	5	use gpui::{actions, App, AppContext as _, Context, Window};
6	use schemars::JsonSchema;	6	use schemars::JsonSchema;
7	use serde::{Deserialize, Serialize};	7	use serde::{Deserialize, Serialize};
8	use settings::{Settings, SettingsSources};	8	use settings::{Settings, SettingsSources};
@@ -87,7 +87,7 @@ pub fn new_journal_entry(workspace: &Workspace, window: &mut Window, cx: &mut Ap · 78 unmodified lines
87	let now = now.time();	87	let now = now.time();
88	let entry_heading = heading_entry(now, &settings.hour_format);	88	let entry_heading = heading_entry(now, &settings.hour_format);
89		89
90	let create_entry = cx.background_executor().spawn(async move {	90	let create_entry = cx.background_spawn(async move {
91	std::fs::create_dir_all(month_dir)?;	91	std::fs::create_dir_all(month_dir)?;
92	OpenOptions::new()	92	OpenOptions::new()
93	.create(true)	93	.create(true)

crates/language/src/buffer.rs+5−5

@@ -940,7 +940,7 @@ impl Buffer { · 939 unmodified lines
940	}	940	}
941		941
942	let text_operations = self.text.operations().clone();	942	let text_operations = self.text.operations().clone();
943	cx.background_executor().spawn(async move {	943	cx.background_spawn(async move {
944	let since = since.unwrap_or_default();	944	let since = since.unwrap_or_default();
945	operations.extend(	945	operations.extend(
946	text_operations	946	text_operations
@@ -1135,7 +1135,7 @@ impl Buffer { · 188 unmodified lines
1135	let old_snapshot = self.text.snapshot();	1135	let old_snapshot = self.text.snapshot();
1136	let mut branch_buffer = self.text.branch();	1136	let mut branch_buffer = self.text.branch();
1137	let mut syntax_snapshot = self.syntax_map.lock().snapshot();	1137	let mut syntax_snapshot = self.syntax_map.lock().snapshot();
1138	cx.background_executor().spawn(async move {	1138	cx.background_spawn(async move {
1139	if !edits.is_empty() {	1139	if !edits.is_empty() {
1140	if let Some(language) = language.clone() {	1140	if let Some(language) = language.clone() {
1141	syntax_snapshot.reparse(&old_snapshot, registry.clone(), language);	1141	syntax_snapshot.reparse(&old_snapshot, registry.clone(), language);
@@ -1499,7 +1499,7 @@ impl Buffer { · 357 unmodified lines
1499	let mut syntax_snapshot = syntax_map.snapshot();	1499	let mut syntax_snapshot = syntax_map.snapshot();
1500	drop(syntax_map);	1500	drop(syntax_map);
1501		1501
1502	let parse_task = cx.background_executor().spawn({	1502	let parse_task = cx.background_spawn({
1503	let language = language.clone();	1503	let language = language.clone();
1504	let language_registry = language_registry.clone();	1504	let language_registry = language_registry.clone();
1505	async move {	1505	async move {
@@ -1578,7 +1578,7 @@ impl Buffer { · 72 unmodified lines
1578		1578
1579	fn request_autoindent(&mut self, cx: &mut Context<Self>) {	1579	fn request_autoindent(&mut self, cx: &mut Context<Self>) {
1580	if let Some(indent_sizes) = self.compute_autoindents() {	1580	if let Some(indent_sizes) = self.compute_autoindents() {
1581	let indent_sizes = cx.background_executor().spawn(indent_sizes);	1581	let indent_sizes = cx.background_spawn(indent_sizes);
1582	match cx	1582	match cx
1583	.background_executor()	1583	.background_executor()
1584	.block_with_timeout(Duration::from_micros(500), indent_sizes)	1584	.block_with_timeout(Duration::from_micros(500), indent_sizes)
@@ -1907,7 +1907,7 @@ impl Buffer { · 322 unmodified lines
1907	let old_text = self.as_rope().clone();	1907	let old_text = self.as_rope().clone();
1908	let line_ending = self.line_ending();	1908	let line_ending = self.line_ending();
1909	let base_version = self.version();	1909	let base_version = self.version();
1910	cx.background_executor().spawn(async move {	1910	cx.background_spawn(async move {
1911	let ranges = trailing_whitespace_ranges(&old_text);	1911	let ranges = trailing_whitespace_ranges(&old_text);
1912	let empty = Arc::<str>::from("");	1912	let empty = Arc::<str>::from("");
1913	Diff {	1913	Diff {

crates/language/src/language_registry.rs+12−11

@@ -940,6 +940,8 @@ impl LanguageRegistry { · 939 unmodified lines
940	binary: lsp::LanguageServerBinary,	940	binary: lsp::LanguageServerBinary,
941	cx: gpui::AsyncApp,	941	cx: gpui::AsyncApp,
942	) -> Option<lsp::LanguageServer> {	942	) -> Option<lsp::LanguageServer> {
		943	use gpui::AppContext as _;
		944
943	let mut state = self.state.write();	945	let mut state = self.state.write();
944	let fake_entry = state.fake_server_entries.get_mut(&name)?;	946	let fake_entry = state.fake_server_entries.get_mut(&name)?;
945	let (server, mut fake_server) = lsp::FakeLanguageServer::new(	947	let (server, mut fake_server) = lsp::FakeLanguageServer::new(
@@ -956,17 +958,16 @@ impl LanguageRegistry { · 10 unmodified lines
956	}	958	}
957		959
958	let tx = fake_entry.tx.clone();	960	let tx = fake_entry.tx.clone();
959	cx.background_executor()	961	cx.background_spawn(async move {
960	.spawn(async move {	962	if fake_server
961	if fake_server	963	.try_receive_notification::<lsp::notification::Initialized>()
962	.try_receive_notification::<lsp::notification::Initialized>()	964	.await
963	.await	965	.is_some()
964	.is_some()	966	{
965	{	967	tx.unbounded_send(fake_server.clone()).ok();
966	tx.unbounded_send(fake_server.clone()).ok();	968	}
967	}	969	})
968	})	970	.detach();
969	.detach();
970		971
971	Some(server)	972	Some(server)
972	}	973	}

crates/language_model/src/request.rs+4−2

 use crate::role::Role;
 use crate::LanguageModelToolUse;
 use base64::write::EncoderWriter;
-use gpui::{point, size, App, DevicePixels, Image, ObjectFit, RenderImage, Size, Task};
+use gpui::{
+    point, size, App, AppContext as _, DevicePixels, Image, ObjectFit, RenderImage, Size, Task,
+};
 use image::{codecs::png::PngEncoder, imageops::resize, DynamicImage, ImageDecoder};
 use serde::{Deserialize, Serialize};
 use ui::{px, SharedString};
 impl LanguageModelImage {
     pub fn from_image(data: Image, cx: &mut App) -> Task<Option<Self>> {
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             match data.format() {
                 gpui::ImageFormat::Png
                 | gpui::ImageFormat::Jpeg

crates/language_model_selector/src/language_model_selector.rs+1−2

@@ -228,8 +228,7 @@ impl PickerDelegate for LanguageModelPickerDelegate { · 227 unmodified lines
228		228
229	cx.spawn_in(window, \|this, mut cx\| async move {	229	cx.spawn_in(window, \|this, mut cx\| async move {
230	let filtered_models = cx	230	let filtered_models = cx
231	.background_executor()	231	.background_spawn(async move {
232	.spawn(async move {
233	let displayed_models = if configured_providers.is_empty() {	232	let displayed_models = if configured_providers.is_empty() {
234	all_models	233	all_models
235	} else {	234	} else {

crates/language_models/src/provider/anthropic.rs+39−40

@@ -252,54 +252,53 @@ pub fn count_anthropic_tokens( · 251 unmodified lines
252	request: LanguageModelRequest,	252	request: LanguageModelRequest,
253	cx: &App,	253	cx: &App,
254	) -> BoxFuture<'static, Result<usize>> {	254	) -> BoxFuture<'static, Result<usize>> {
255	cx.background_executor()	255	cx.background_spawn(async move {
256	.spawn(async move {	256	let messages = request.messages;
257	let messages = request.messages;	257	let mut tokens_from_images = 0;
258	let mut tokens_from_images = 0;	258	let mut string_messages = Vec::with_capacity(messages.len());
259	let mut string_messages = Vec::with_capacity(messages.len());
260		259
261	for message in messages {	260	for message in messages {
262	use language_model::MessageContent;	261	use language_model::MessageContent;
263		262
264	let mut string_contents = String::new();	263	let mut string_contents = String::new();
265		264
266	for content in message.content {	265	for content in message.content {
267	match content {	266	match content {
268	MessageContent::Text(text) => {	267	MessageContent::Text(text) => {
269	string_contents.push_str(&text);	268	string_contents.push_str(&text);
270	}	269	}
271	MessageContent::Image(image) => {	270	MessageContent::Image(image) => {
272	tokens_from_images += image.estimate_tokens();	271	tokens_from_images += image.estimate_tokens();
273	}	272	}
274	MessageContent::ToolUse(_tool_use) => {	273	MessageContent::ToolUse(_tool_use) => {
275	// TODO: Estimate token usage from tool uses.	274	// TODO: Estimate token usage from tool uses.
276	}	275	}
277	MessageContent::ToolResult(tool_result) => {	276	MessageContent::ToolResult(tool_result) => {
278	string_contents.push_str(&tool_result.content);	277	string_contents.push_str(&tool_result.content);
279	}
280	}	278	}
281	}	279	}
		280	}
282		281
283	if !string_contents.is_empty() {	282	if !string_contents.is_empty() {
284	string_messages.push(tiktoken_rs::ChatCompletionRequestMessage {	283	string_messages.push(tiktoken_rs::ChatCompletionRequestMessage {
285	role: match message.role {	284	role: match message.role {
286	Role::User => "user".into(),	285	Role::User => "user".into(),
287	Role::Assistant => "assistant".into(),	286	Role::Assistant => "assistant".into(),
288	Role::System => "system".into(),	287	Role::System => "system".into(),
289	},	288	},
290	content: Some(string_contents),	289	content: Some(string_contents),
291	name: None,	290	name: None,
292	function_call: None,	291	function_call: None,
293	});	292	});
294	}
295	}	293	}
		294	}
296		295
297	// Tiktoken doesn't yet support these models, so we manually use the	296	// Tiktoken doesn't yet support these models, so we manually use the
298	// same tokenizer as GPT-4.	297	// same tokenizer as GPT-4.
299	tiktoken_rs::num_tokens_from_messages("gpt-4", &string_messages)	298	tiktoken_rs::num_tokens_from_messages("gpt-4", &string_messages)
300	.map(\|tokens\| tokens + tokens_from_images)	299	.map(\|tokens\| tokens + tokens_from_images)
301	})	300	})
302	.boxed()	301	.boxed()
303	}	302	}
304		303
305	impl AnthropicModel {	304	impl AnthropicModel {

crates/language_models/src/provider/deepseek.rs+20−20

@@ -3,7 +3,8 @@ use collections::BTreeMap; · 2 unmodified lines
3	use editor::{Editor, EditorElement, EditorStyle};	3	use editor::{Editor, EditorElement, EditorStyle};
4	use futures::{future::BoxFuture, stream::BoxStream, FutureExt, StreamExt};	4	use futures::{future::BoxFuture, stream::BoxStream, FutureExt, StreamExt};
5	use gpui::{	5	use gpui::{
6	AnyView, AppContext, AsyncApp, Entity, FontStyle, Subscription, Task, TextStyle, WhiteSpace,	6	AnyView, AppContext as _, AsyncApp, Entity, FontStyle, Subscription, Task, TextStyle,
		7	WhiteSpace,
7	};	8	};
8	use http_client::HttpClient;	9	use http_client::HttpClient;
9	use language_model::{	10	use language_model::{
@@ -269,26 +270,25 @@ impl LanguageModel for DeepSeekLanguageModel { · 259 unmodified lines
269	request: LanguageModelRequest,	270	request: LanguageModelRequest,
270	cx: &App,	271	cx: &App,
271	) -> BoxFuture<'static, Result<usize>> {	272	) -> BoxFuture<'static, Result<usize>> {
272	cx.background_executor()	273	cx.background_spawn(async move {
273	.spawn(async move {	274	let messages = request
274	let messages = request	275	.messages
275	.messages	276	.into_iter()
276	.into_iter()	277	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {
277	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {	278	role: match message.role {
278	role: match message.role {	279	Role::User => "user".into(),
279	Role::User => "user".into(),	280	Role::Assistant => "assistant".into(),
280	Role::Assistant => "assistant".into(),	281	Role::System => "system".into(),
281	Role::System => "system".into(),	282	},
282	},	283	content: Some(message.string_contents()),
283	content: Some(message.string_contents()),	284	name: None,
284	name: None,	285	function_call: None,
285	function_call: None,	286	})
286	})	287	.collect::<Vec<_>>();
287	.collect::<Vec<_>>();
288		288
289	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)	289	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
290	})	290	})
291	.boxed()	291	.boxed()
292	}	292	}
293		293
294	fn stream_completion(	294	fn stream_completion(

crates/language_models/src/provider/google.rs+20−21

@@ -330,28 +330,27 @@ pub fn count_google_tokens( · 329 unmodified lines
330	) -> BoxFuture<'static, Result<usize>> {	330	) -> BoxFuture<'static, Result<usize>> {
331	// We couldn't use the GoogleLanguageModelProvider to count tokens because the github copilot doesn't have the access to google_ai directly.	331	// We couldn't use the GoogleLanguageModelProvider to count tokens because the github copilot doesn't have the access to google_ai directly.
332	// So we have to use tokenizer from tiktoken_rs to count tokens.	332	// So we have to use tokenizer from tiktoken_rs to count tokens.
333	cx.background_executor()	333	cx.background_spawn(async move {
334	.spawn(async move {	334	let messages = request
335	let messages = request	335	.messages
336	.messages	336	.into_iter()
337	.into_iter()	337	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {
338	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {	338	role: match message.role {
339	role: match message.role {	339	Role::User => "user".into(),
340	Role::User => "user".into(),	340	Role::Assistant => "assistant".into(),
341	Role::Assistant => "assistant".into(),	341	Role::System => "system".into(),
342	Role::System => "system".into(),	342	},
343	},	343	content: Some(message.string_contents()),
344	content: Some(message.string_contents()),	344	name: None,
345	name: None,	345	function_call: None,
346	function_call: None,	346	})
347	})	347	.collect::<Vec<_>>();
348	.collect::<Vec<_>>();
349		348
350	// Tiktoken doesn't yet support these models, so we manually use the	349	// Tiktoken doesn't yet support these models, so we manually use the
351	// same tokenizer as GPT-4.	350	// same tokenizer as GPT-4.
352	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)	351	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
353	})	352	})
354	.boxed()	353	.boxed()
355	}	354	}
356		355
357	struct ConfigurationView {	356	struct ConfigurationView {

crates/language_models/src/provider/mistral.rs+18−19

@@ -281,26 +281,25 @@ impl LanguageModel for MistralLanguageModel { · 280 unmodified lines
281	request: LanguageModelRequest,	281	request: LanguageModelRequest,
282	cx: &App,	282	cx: &App,
283	) -> BoxFuture<'static, Result<usize>> {	283	) -> BoxFuture<'static, Result<usize>> {
284	cx.background_executor()	284	cx.background_spawn(async move {
285	.spawn(async move {	285	let messages = request
286	let messages = request	286	.messages
287	.messages	287	.into_iter()
288	.into_iter()	288	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {
289	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {	289	role: match message.role {
290	role: match message.role {	290	Role::User => "user".into(),
291	Role::User => "user".into(),	291	Role::Assistant => "assistant".into(),
292	Role::Assistant => "assistant".into(),	292	Role::System => "system".into(),
293	Role::System => "system".into(),	293	},
294	},	294	content: Some(message.string_contents()),
295	content: Some(message.string_contents()),	295	name: None,
296	name: None,	296	function_call: None,
297	function_call: None,	297	})
298	})	298	.collect::<Vec<_>>();
299	.collect::<Vec<_>>();
300		299
301	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)	300	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
302	})	301	})
303	.boxed()	302	.boxed()
304	}	303	}
305		304
306	fn stream_completion(	305	fn stream_completion(

crates/language_models/src/provider/open_ai.rs+25−28

@@ -343,34 +343,31 @@ pub fn count_open_ai_tokens( · 342 unmodified lines
343	model: open_ai::Model,	343	model: open_ai::Model,
344	cx: &App,	344	cx: &App,
345	) -> BoxFuture<'static, Result<usize>> {	345	) -> BoxFuture<'static, Result<usize>> {
346	cx.background_executor()	346	cx.background_spawn(async move {
347	.spawn(async move {	347	let messages = request
348	let messages = request	348	.messages
349	.messages	349	.into_iter()
350	.into_iter()	350	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {
351	.map(\|message\| tiktoken_rs::ChatCompletionRequestMessage {	351	role: match message.role {
352	role: match message.role {	352	Role::User => "user".into(),
353	Role::User => "user".into(),	353	Role::Assistant => "assistant".into(),
354	Role::Assistant => "assistant".into(),	354	Role::System => "system".into(),
355	Role::System => "system".into(),	355	},
356	},	356	content: Some(message.string_contents()),
357	content: Some(message.string_contents()),	357	name: None,
358	name: None,	358	function_call: None,
359	function_call: None,	359	})
360	})	360	.collect::<Vec<_>>();
361	.collect::<Vec<_>>();	361
362		362	match model {
363	match model {	363	open_ai::Model::Custom { .. }
364	open_ai::Model::Custom { .. }	364	\| open_ai::Model::O1Mini
365	\| open_ai::Model::O1Mini	365	\| open_ai::Model::O1
366	\| open_ai::Model::O1	366	\| open_ai::Model::O3Mini => tiktoken_rs::num_tokens_from_messages("gpt-4", &messages),
367	\| open_ai::Model::O3Mini => {	367	_ => tiktoken_rs::num_tokens_from_messages(model.id(), &messages),
368	tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)	368	}
369	}	369	})
370	_ => tiktoken_rs::num_tokens_from_messages(model.id(), &messages),	370	.boxed()
371	}
372	})
373	.boxed()
374	}	371	}
375		372
376	struct ConfigurationView {	373	struct ConfigurationView {

crates/livekit_client/examples/test_app.rs+4−5

         if let Some(track) = self.screen_share_track.take() {
             self.screen_share_stream.take();
             let participant = self.room.local_participant();
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                participant.unpublish_track(&track.sid()).await.unwrap();
-                    participant.unpublish_track(&track.sid()).await.unwrap();
+            })
-                })
+            .detach();
-                .detach();
             cx.notify();
         } else {
             let participant = self.room.local_participant();

crates/livekit_client/src/remote_video_track_view.rs+3−1

 use crate::track::RemoteVideoTrack;
 use anyhow::Result;
 use futures::StreamExt as _;
-use gpui::{AppContext, Context, Empty, Entity, EventEmitter, IntoElement, Render, Task, Window};
+use gpui::{
+    AppContext as _, Context, Empty, Entity, EventEmitter, IntoElement, Render, Task, Window,
+};
 pub struct RemoteVideoTrackView {
     track: RemoteVideoTrack,

crates/lsp/src/lsp.rs+2−2

@@ -6,7 +6,7 @@ pub use lsp_types::*; · 5 unmodified lines
6	use anyhow::{anyhow, Context as _, Result};	6	use anyhow::{anyhow, Context as _, Result};
7	use collections::HashMap;	7	use collections::HashMap;
8	use futures::{channel::oneshot, io::BufWriter, select, AsyncRead, AsyncWrite, Future, FutureExt};	8	use futures::{channel::oneshot, io::BufWriter, select, AsyncRead, AsyncWrite, Future, FutureExt};
9	use gpui::{App, AsyncApp, BackgroundExecutor, SharedString, Task};	9	use gpui::{App, AppContext as _, AsyncApp, BackgroundExecutor, SharedString, Task};
10	use notification::DidChangeWorkspaceFolders;	10	use notification::DidChangeWorkspaceFolders;
11	use parking_lot::{Mutex, RwLock};	11	use parking_lot::{Mutex, RwLock};
12	use postage::{barrier, prelude::Stream};	12	use postage::{barrier, prelude::Stream};
@@ -448,7 +448,7 @@ impl LanguageServer { · 435 unmodified lines
448	let (stdout, stderr) = futures::join!(stdout_input_task, stderr_input_task);	448	let (stdout, stderr) = futures::join!(stdout_input_task, stderr_input_task);
449	stdout.or(stderr)	449	stdout.or(stderr)
450	});	450	});
451	let output_task = cx.background_executor().spawn({	451	let output_task = cx.background_spawn({
452	Self::handle_output(	452	Self::handle_output(
453	stdin,	453	stdin,
454	outbound_rx,	454	outbound_rx,

crates/markdown/src/markdown.rs+1−1

@@ -178,7 +178,7 @@ impl Markdown { · 177 unmodified lines
178		178
179	let text = self.source.clone();	179	let text = self.source.clone();
180	let parse_text_only = self.options.parse_links_only;	180	let parse_text_only = self.options.parse_links_only;
181	let parsed = cx.background_executor().spawn(async move {	181	let parsed = cx.background_spawn(async move {
182	let text = SharedString::from(text);	182	let text = SharedString::from(text);
183	let events = match parse_text_only {	183	let events = match parse_text_only {
184	true => Arc::from(parse_links_only(text.as_ref())),	184	true => Arc::from(parse_links_only(text.as_ref())),

crates/markdown_preview/src/markdown_preview_view.rs+1−1

@@ -383,7 +383,7 @@ impl MarkdownPreviewView { · 382 unmodified lines
383	(contents, file_location)	383	(contents, file_location)
384	})?;	384	})?;
385		385
386	let parsing_task = cx.background_executor().spawn(async move {	386	let parsing_task = cx.background_spawn(async move {
387	parse_markdown(&contents, file_location, Some(language_registry)).await	387	parse_markdown(&contents, file_location, Some(language_registry)).await
388	});	388	});
389	let contents = parsing_task.await;	389	let contents = parsing_task.await;

crates/multi_buffer/src/multi_buffer.rs+14−18

@@ -13,7 +13,7 @@ use buffer_diff::{ · 12 unmodified lines
13	use clock::ReplicaId;	13	use clock::ReplicaId;
14	use collections::{BTreeMap, Bound, HashMap, HashSet};	14	use collections::{BTreeMap, Bound, HashMap, HashSet};
15	use futures::{channel::mpsc, SinkExt};	15	use futures::{channel::mpsc, SinkExt};
16	use gpui::{App, Context, Entity, EntityId, EventEmitter, Task};	16	use gpui::{App, AppContext as _, Context, Entity, EntityId, EventEmitter, Task};
17	use itertools::Itertools;	17	use itertools::Itertools;
18	use language::{	18	use language::{
19	language_settings::{language_settings, IndentGuideSettings, LanguageSettings},	19	language_settings::{language_settings, IndentGuideSettings, LanguageSettings},
@@ -51,9 +51,6 @@ use text::{ · 31 unmodified lines
51	use theme::SyntaxTheme;	51	use theme::SyntaxTheme;
52	use util::post_inc;	52	use util::post_inc;
53		53
54	#[cfg(any(test, feature = "test-support"))]
55	use gpui::AppContext as _;
56
57	const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];	54	const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];
58		55
59	#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]	56	#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
@@ -1580,20 +1577,19 @@ impl MultiBuffer { · 1520 unmodified lines
1580		1577
1581	buffer_ids.push(buffer_id);	1578	buffer_ids.push(buffer_id);
1582		1579
1583	cx.background_executor()	1580	cx.background_spawn({
1584	.spawn({	1581	let mut excerpt_ranges_tx = excerpt_ranges_tx.clone();
1585	let mut excerpt_ranges_tx = excerpt_ranges_tx.clone();	1582
1586		1583	async move {
1587	async move {	1584	let (excerpt_ranges, counts) =
1588	let (excerpt_ranges, counts) =	1585	build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
1589	build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);	1586	excerpt_ranges_tx
1590	excerpt_ranges_tx	1587	.send((buffer_id, buffer.clone(), ranges, excerpt_ranges, counts))
1591	.send((buffer_id, buffer.clone(), ranges, excerpt_ranges, counts))	1588	.await
1592	.await	1589	.ok();
1593	.ok();	1590	}
1594	}	1591	})
1595	})	1592	.detach()
1596	.detach()
1597	}	1593	}
1598		1594
1599	cx.spawn(move \|this, mut cx\| async move {	1595	cx.spawn(move \|this, mut cx\| async move {

crates/outline_panel/src/outline_panel.rs+5−8

                 })
                 .collect(),
             highlight_search_match_tx,
-            _search_match_highlighter: cx.background_executor().spawn(async move {
+            _search_match_highlighter: cx.background_spawn(async move {
                 while let Ok(highlight_arguments) = highlight_search_match_rx.recv().await {
                     let needs_init = highlight_arguments.search_data.get().is_none();
                     let search_data = highlight_arguments.search_data.get_or_init(|| {
         mut cx: AsyncWindowContext,
     ) -> anyhow::Result<Entity<Self>> {
         let serialized_panel = cx
-            .background_executor()
+            .background_spawn(async move { KEY_VALUE_STORE.read_kvp(OUTLINE_PANEL_KEY) })
-            .spawn(async move { KEY_VALUE_STORE.read_kvp(OUTLINE_PANEL_KEY) })
             .await
             .context("loading outline panel")
             .log_err()
     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
         let active = Some(self.active);
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(
                 new_depth_map,
                 new_children_count,
             )) = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     let mut processed_external_buffers = HashSet::default();
                     let mut new_worktree_entries =
                         BTreeMap::<WorktreeId, HashMap<ProjectEntryId, GitEntry>>::default();
                     (buffer_id, excerpt_id),
                     cx.spawn_in(window, |outline_panel, mut cx| async move {
                         let fetched_outlines = cx
-                            .background_executor()
+                            .background_spawn(async move {
-                            .spawn(async move {
                                 buffer_snapshot
                                     .outline_items_containing(
                                         excerpt_range.context,

crates/project/src/buffer_store.rs+46−55

     fn open_unstaged_diff(&self, buffer_id: BufferId, cx: &App) -> Task<Result<Option<String>>> {
         let project_id = self.project_id;
         let client = self.upstream_client.clone();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let response = client
                 .request(proto::OpenUnstagedDiff {
                     project_id,
         let project_id = self.project_id;
         let client = self.upstream_client.clone();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let response = client
                 .request(proto::OpenUncommittedDiff {
                     project_id,
                 return Ok(buffer);
             }
-            cx.background_executor()
+            cx.background_spawn(async move { rx.await? }).await
-                .spawn(async move { rx.await? })
-                .await
         })
     }
             let snapshot =
                 worktree_handle.update(&mut cx, |tree, _| tree.as_local().unwrap().snapshot())?;
             let diff_bases_changes_by_buffer = cx
-                .background_executor()
+                .background_spawn(async move {
-                .spawn(async move {
                     diff_state_updates
                         .into_iter()
                         .filter_map(
             cx.spawn(move |_, mut cx| async move {
                 let loaded = load_file.await?;
                 let text_buffer = cx
-                    .background_executor()
+                    .background_spawn(async move { text::Buffer::new(0, buffer_id, loaded.text) })
-                    .spawn(async move { text::Buffer::new(0, buffer_id, loaded.text) })
                     .await;
                 cx.insert_entity(reservation, |_| {
                     Buffer::build(text_buffer, Some(loaded.file), Capability::ReadWrite)
             }
         };
-        cx.background_executor()
+        cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
-            .spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
     }
     pub fn open_unstaged_diff(
             }
         };
-        cx.background_executor()
+        cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
-            .spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
     }
     pub fn open_uncommitted_diff(
                     BufferStoreState::Local(this) => {
                         let committed_text = this.load_committed_text(&buffer, cx);
                         let staged_text = this.load_staged_text(&buffer, cx);
-                        cx.background_executor().spawn(async move {
+                        cx.background_spawn(async move {
                             let committed_text = committed_text.await?;
                             let staged_text = staged_text.await?;
                             let diff_bases_change = if committed_text == staged_text {
             }
         };
-        cx.background_executor()
+        cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
-            .spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
     }
     async fn open_diff_internal(
                     anyhow::Ok(Some((repo, relative_path, content)))
                 });
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     let Some((repo, relative_path, content)) = blame_params? else {
                         return Ok(None);
                     };
                     })
                     .log_err();
-                cx.background_executor()
+                cx.background_spawn(
-                    .spawn(
+                    async move {
-                        async move {
+                        let operations = operations.await;
-                            let operations = operations.await;
+                        for chunk in split_operations(operations) {
-                            for chunk in split_operations(operations) {
+                            client
-                                client
+                                .request(proto::UpdateBuffer {
-                                    .request(proto::UpdateBuffer {
+                                    project_id,
-                                        project_id,
+                                    buffer_id: buffer_id.into(),
-                                        buffer_id: buffer_id.into(),
+                                    operations: chunk,
-                                        operations: chunk,
+                                })
-                                    })
+                                .await?;
-                                    .await?;
-                            }
-                            anyhow::Ok(())
                         }
-                        .log_err(),
+                        anyhow::Ok(())
-                    )
+                    }
-                    .detach();
+                    .log_err(),
+                )
+                .detach();
             }
         }
         Ok(response)
             if client.send(initial_state).log_err().is_some() {
                 let client = client.clone();
-                cx.background_executor()
+                cx.background_spawn(async move {
-                    .spawn(async move {
+                    let mut chunks = split_operations(operations).peekable();
-                        let mut chunks = split_operations(operations).peekable();
+                    while let Some(chunk) = chunks.next() {
-                        while let Some(chunk) = chunks.next() {
+                        let is_last = chunks.peek().is_none();
-                            let is_last = chunks.peek().is_none();
+                        client.send(proto::CreateBufferForPeer {
-                            client.send(proto::CreateBufferForPeer {
+                            project_id,
-                                project_id,
+                            peer_id: Some(peer_id),
-                                peer_id: Some(peer_id),
+                            variant: Some(proto::create_buffer_for_peer::Variant::Chunk(
-                                variant: Some(proto::create_buffer_for_peer::Variant::Chunk(
+                                proto::BufferChunk {
-                                    proto::BufferChunk {
+                                    buffer_id: buffer_id.into(),
-                                        buffer_id: buffer_id.into(),
+                                    operations: chunk,
-                                        operations: chunk,
+                                    is_last,
-                                        is_last,
+                                },
-                                    },
+                            )),
-                                )),
+                        })?;
-                            })?;
+                    }
-                        }
+                    anyhow::Ok(())
-                        anyhow::Ok(())
+                })
-                    })
+                .await
-                    .await
+                .log_err();
-                    .log_err();
             }
             Ok(())
         })

crates/project/src/environment.rs+1−2

@@ -135,8 +135,7 @@ impl ProjectEnvironment { · 134 unmodified lines
135		135
136	cx.spawn(\|this, mut cx\| async move {	136	cx.spawn(\|this, mut cx\| async move {
137	let (mut shell_env, error_message) = cx	137	let (mut shell_env, error_message) = cx
138	.background_executor()	138	.background_spawn({
139	.spawn({
140	let worktree_abs_path = worktree_abs_path.clone();	139	let worktree_abs_path = worktree_abs_path.clone();
141	async move {	140	async move {
142	load_worktree_shell_environment(&worktree_abs_path, &load_direnv).await	141	load_worktree_shell_environment(&worktree_abs_path, &load_direnv).await

crates/project/src/git.rs+5−9

     status::{GitSummary, TrackedSummary},
 };
 use gpui::{
-    App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Subscription, Task,
+    App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, SharedString, Subscription,
-    WeakEntity,
+    Task, WeakEntity,
 };
 use language::{Buffer, LanguageRegistry};
 use rpc::proto::{git_reset, ToProto};
             mpsc::unbounded::<(Message, oneshot::Sender<Result<()>>)>();
         cx.spawn(|_, cx| async move {
             while let Some((msg, respond)) = update_receiver.next().await {
-                let result = cx
+                let result = cx.background_spawn(Self::process_git_msg(msg)).await;
-                    .background_executor()
-                    .spawn(Self::process_git_msg(msg))
-                    .await;
                 respond.send(result).ok();
             }
         })
         match self.git_repo.clone() {
             GitRepo::Local(git_repository) => {
                 let commit = commit.to_string();
-                cx.background_executor()
+                cx.background_spawn(async move { git_repository.show(&commit) })
-                    .spawn(async move { git_repository.show(&commit) })
             }
             GitRepo::Remote {
                 project_id,
                 client,
                 worktree_id,
                 work_directory_id,
-            } => cx.background_executor().spawn(async move {
+            } => cx.background_spawn(async move {
                 let resp = client
                     .request(proto::GitShow {
                         project_id: project_id.0,

crates/project/src/image_store.rs+1−1

@@ -404,7 +404,7 @@ impl ImageStore { · 403 unmodified lines
404	}	404	}
405	};	405	};
406		406
407	cx.background_executor().spawn(async move {	407	cx.background_spawn(async move {
408	Self::wait_for_loading_image(loading_watch)	408	Self::wait_for_loading_image(loading_watch)
409	.await	409	.await
410	.map_err(\|e\| e.cloned())	410	.map_err(\|e\| e.cloned())

crates/project/src/lsp_store.rs+15−24

         cx: &mut Context<LspStore>,
     ) -> Task<Result<Vec<(Range<Anchor>, String)>>> {
         let snapshot = self.buffer_snapshot_for_lsp_version(buffer, server_id, version, cx);
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let snapshot = snapshot?;
             let mut lsp_edits = lsp_edits
                 .into_iter()
             }
         } else if let Some((upstream_client, upstream_project_id)) = self.upstream_client() {
             let buffer_id = buffer.read(cx).remote_id().to_proto();
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                upstream_client
-                    upstream_client
+                    .request(proto::RegisterBufferWithLanguageServers {
-                        .request(proto::RegisterBufferWithLanguageServers {
+                        project_id: upstream_project_id,
-                            project_id: upstream_project_id,
+                        buffer_id,
-                            buffer_id,
+                    })
-                        })
+                    .await
-                        .await
+            })
-                })
+            .detach();
-                .detach();
         } else {
             panic!("oops!");
         }
                     return Err(anyhow!("No language server {id}"));
                 };
-                Ok(cx.background_executor().spawn(async move {
+                Ok(cx.background_spawn(async move {
                     let can_resolve = server
                         .capabilities()
                         .completion_provider
                     .map(|b| b.read(cx).remote_id().to_proto())
                     .collect(),
             });
-            cx.background_executor()
+            cx.background_spawn(request).detach_and_log_err(cx);
-                .spawn(request)
-                .detach_and_log_err(cx);
         } else {
             let Some(local) = self.as_local_mut() else {
                 return;
                 .collect::<Vec<_>>();
             cx.spawn(|this, mut cx| async move {
-                cx.background_executor()
+                cx.background_spawn(futures::future::join_all(tasks)).await;
-                    .spawn(futures::future::join_all(tasks))
-                    .await;
                 this.update(&mut cx, |this, cx| {
                     for buffer in buffers {
                         this.register_buffer_with_language_servers(&buffer, true, cx);
                     },
                 )),
             });
-            cx.background_executor()
+            cx.background_spawn(request).detach_and_log_err(cx);
-                .spawn(request)
-                .detach_and_log_err(cx);
         } else if let Some(local) = self.as_local() {
             let servers = buffers
                 .into_iter()
                     ),
                 ),
             });
-            cx.background_executor()
+            cx.background_spawn(request).detach_and_log_err(cx);
-                .spawn(request)
-                .detach_and_log_err(cx);
         }
     }

crates/project/src/prettier_store.rs+32−36

@@ -12,7 +12,7 @@ use futures::{ · 11 unmodified lines
12	stream::FuturesUnordered,	12	stream::FuturesUnordered,
13	FutureExt,	13	FutureExt,
14	};	14	};
15	use gpui::{AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity};	15	use gpui::{AppContext as _, AsyncApp, Context, Entity, EventEmitter, Task, WeakEntity};
16	use language::{	16	use language::{
17	language_settings::{Formatter, LanguageSettings, SelectedFormatter},	17	language_settings::{Formatter, LanguageSettings, SelectedFormatter},
18	Buffer, LanguageRegistry, LocalFile,	18	Buffer, LanguageRegistry, LocalFile,
@@ -121,8 +121,7 @@ impl PrettierStore { · 102 unmodified lines
121	let installed_prettiers = self.prettier_instances.keys().cloned().collect();	121	let installed_prettiers = self.prettier_instances.keys().cloned().collect();
122	cx.spawn(\|lsp_store, mut cx\| async move {	122	cx.spawn(\|lsp_store, mut cx\| async move {
123	match cx	123	match cx
124	.background_executor()	124	.background_spawn(async move {
125	.spawn(async move {
126	Prettier::locate_prettier_installation(	125	Prettier::locate_prettier_installation(
127	fs.as_ref(),	126	fs.as_ref(),
128	&installed_prettiers,	127	&installed_prettiers,
@@ -234,8 +233,7 @@ impl PrettierStore { · 105 unmodified lines
234	.unwrap_or_default();	233	.unwrap_or_default();
235	cx.spawn(\|lsp_store, mut cx\| async move {	234	cx.spawn(\|lsp_store, mut cx\| async move {
236	match cx	235	match cx
237	.background_executor()	236	.background_spawn(async move {
238	.spawn(async move {
239	Prettier::locate_prettier_ignore(	237	Prettier::locate_prettier_ignore(
240	fs.as_ref(),	238	fs.as_ref(),
241	&prettier_ignores,	239	&prettier_ignores,
@@ -483,31 +481,30 @@ impl PrettierStore { · 241 unmodified lines
483	}))	481	}))
484	.collect::<Vec<_>>();	482	.collect::<Vec<_>>();
485		483
486	cx.background_executor()	484	cx.background_spawn(async move {
487	.spawn(async move {	485	let _: Vec<()> = future::join_all(prettiers_to_reload.into_iter().map(\|(worktree_id, prettier_path, prettier_instance)\| {
488	let _: Vec<()> = future::join_all(prettiers_to_reload.into_iter().map(\|(worktree_id, prettier_path, prettier_instance)\| {	486	async move {
489	async move {	487	if let Some(instance) = prettier_instance.prettier {
490	if let Some(instance) = prettier_instance.prettier {	488	match instance.await {
491	match instance.await {	489	Ok(prettier) => {
492	Ok(prettier) => {	490	prettier.clear_cache().log_err().await;
493	prettier.clear_cache().log_err().await;	491	},
494	},	492	Err(e) => {
495	Err(e) => {	493	match prettier_path {
496	match prettier_path {	494	Some(prettier_path) => log::error!(
497	Some(prettier_path) => log::error!(	495	"Failed to clear prettier {prettier_path:?} cache for worktree {worktree_id:?} on prettier settings update: {e:#}"
498	"Failed to clear prettier {prettier_path:?} cache for worktree {worktree_id:?} on prettier settings update: {e:#}"	496	),
499	),	497	None => log::error!(
500	None => log::error!(	498	"Failed to clear default prettier cache for worktree {worktree_id:?} on prettier settings update: {e:#}"
501	"Failed to clear default prettier cache for worktree {worktree_id:?} on prettier settings update: {e:#}"	499	),
502	),	500	}
503	}	501	},
504	},
505	}
506	}	502	}
507	}	503	}
508	}))	504	}
509	.await;	505	}))
510	})	506	.await;
		507	})
511	.detach();	508	.detach();
512	}	509	}
513	}	510	}
@@ -539,7 +536,7 @@ impl PrettierStore { · 25 unmodified lines
539	}) {	536	}) {
540	Some(locate_from) => {	537	Some(locate_from) => {
541	let installed_prettiers = self.prettier_instances.keys().cloned().collect();	538	let installed_prettiers = self.prettier_instances.keys().cloned().collect();
542	cx.background_executor().spawn(async move {	539	cx.background_spawn(async move {
543	Prettier::locate_prettier_installation(	540	Prettier::locate_prettier_installation(
544	fs.as_ref(),	541	fs.as_ref(),
545	&installed_prettiers,	542	&installed_prettiers,
@@ -631,13 +628,12 @@ impl PrettierStore { · 85 unmodified lines
631	})?;	628	})?;
632	if needs_install {	629	if needs_install {
633	let installed_plugins = new_plugins.clone();	630	let installed_plugins = new_plugins.clone();
634	cx.background_executor()	631	cx.background_spawn(async move {
635	.spawn(async move {	632	install_prettier_packages(fs.as_ref(), new_plugins, node).await?;
636	install_prettier_packages(fs.as_ref(), new_plugins, node).await?;	633	// Save the server file last, so the reinstall need could be determined by the absence of the file.
637	// Save the server file last, so the reinstall need could be determined by the absence of the file.	634	save_prettier_server_file(fs.as_ref()).await?;
638	save_prettier_server_file(fs.as_ref()).await?;	635	anyhow::Ok(())
639	anyhow::Ok(())	636	})
640	})
641	.await	637	.await
642	.context("prettier & plugins install")	638	.context("prettier & plugins install")
643	.map_err(Arc::new)?;	639	.map_err(Arc::new)?;

crates/project/src/project.rs+20−24

             }
             DirectoryLister::Local(fs) => {
                 let fs = fs.clone();
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     let mut results = vec![];
                     let expanded = shellexpand::tilde(&path);
                     let query = Path::new(expanded.as_ref());
                 .read(cx)
                 .shutdown_processes(Some(proto::ShutdownRemoteServer {}));
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                if let Some(shutdown) = shutdown {
-                    if let Some(shutdown) = shutdown {
+                    shutdown.await;
-                        shutdown.await;
+                }
-                    }
+            })
-                })
+            .detach()
-                .detach()
         }
         match &self.client_state {
                     let buffer = buffer.clone();
                     let query = query.clone();
                     let snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot())?;
-                    chunk_results.push(cx.background_executor().spawn(async move {
+                    chunk_results.push(cx.background_spawn(async move {
                         let ranges = query
                             .search(&snapshot, None)
                             .await
         cx: &mut Context<Self>,
     ) -> Task<Option<ResolvedPath>> {
         let resolve_task = self.resolve_abs_path(path, cx);
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let resolved_path = resolve_task.await;
             resolved_path.filter(|path| path.is_file())
         })
         if self.is_local() {
             let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
             let fs = self.fs.clone();
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 let path = expanded.as_path();
                 let metadata = fs.metadata(path).await.ok().flatten();
                     project_id: SSH_PROJECT_ID,
                     path: request_path.to_proto(),
                 });
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 let response = request.await.log_err()?;
                 if response.exists {
                     Some(ResolvedPath::AbsPath {
             };
             let response = session.read(cx).proto_client().request(request);
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 let response = response.await?;
                 Ok(response.entries.into_iter().map(PathBuf::from).collect())
             })
             if let Some(remote_id) = this.remote_id() {
                 let mut payload = envelope.payload.clone();
                 payload.project_id = remote_id;
-                cx.background_executor()
+                cx.background_spawn(this.client.request(payload))
-                    .spawn(this.client.request(payload))
                     .detach_and_log_err(cx);
             }
             this.buffer_store.clone()
             if let Some(ssh) = &this.ssh_client {
                 let mut payload = envelope.payload.clone();
                 payload.project_id = SSH_PROJECT_ID;
-                cx.background_executor()
+                cx.background_spawn(ssh.read(cx).proto_client().request(payload))
-                    .spawn(ssh.read(cx).proto_client().request(payload))
                     .detach_and_log_err(cx);
             }
             this.buffer_store.clone()
                         if let Some(buffer) = this.buffer_for_id(buffer_id, cx) {
                             let operations =
                                 buffer.read(cx).serialize_ops(Some(remote_version), cx);
-                            cx.background_executor().spawn(async move {
+                            cx.background_spawn(async move {
                                 let operations = operations.await;
                                 for chunk in split_operations(operations) {
                                     client
             // Any incomplete buffers have open requests waiting. Request that the host sends
             // creates these buffers for us again to unblock any waiting futures.
             for id in incomplete_buffer_ids {
-                cx.background_executor()
+                cx.background_spawn(client.request(proto::OpenBufferById {
-                    .spawn(client.request(proto::OpenBufferById {
+                    project_id,
-                        project_id,
+                    id: id.into(),
-                        id: id.into(),
+                }))
-                    }))
+                .detach();
-                    .detach();
             }
             futures::future::join_all(send_updates_for_buffers)

crates/project/src/project_tree.rs+1−1

@@ -13,7 +13,7 @@ use std::{ · 12 unmodified lines
13	};	13	};
14		14
15	use collections::HashMap;	15	use collections::HashMap;
16	use gpui::{App, AppContext, Context, Entity, EventEmitter, Subscription};	16	use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Subscription};
17	use language::{CachedLspAdapter, LspAdapterDelegate};	17	use language::{CachedLspAdapter, LspAdapterDelegate};
18	use lsp::LanguageServerName;	18	use lsp::LanguageServerName;
19	use path_trie::{LabelPresence, RootPathTrie, TriePath};	19	use path_trie::{LabelPresence, RootPathTrie, TriePath};

crates/project/src/project_tree/server_tree.rs+1−1

@@ -15,7 +15,7 @@ use std::{ · 14 unmodified lines
15	};	15	};
16		16
17	use collections::{HashMap, IndexMap};	17	use collections::{HashMap, IndexMap};
18	use gpui::{App, AppContext, Entity, Subscription};	18	use gpui::{App, AppContext as _, Entity, Subscription};
19	use itertools::Itertools;	19	use itertools::Itertools;
20	use language::{	20	use language::{
21	language_settings::AllLanguageSettings, Attach, LanguageName, LanguageRegistry,	21	language_settings::AllLanguageSettings, Attach, LanguageName, LanguageRegistry,

crates/project/src/toolchain_store.rs+9−10

@@ -325,16 +325,15 @@ impl LocalToolchainStore { · 324 unmodified lines
325	.ok()?	325	.ok()?
326	.await;	326	.await;
327		327
328	cx.background_executor()	328	cx.background_spawn(async move {
329	.spawn(async move {	329	let language = registry
330	let language = registry	330	.language_for_name(language_name.as_ref())
331	.language_for_name(language_name.as_ref())	331	.await
332	.await	332	.ok()?;
333	.ok()?;	333	let toolchains = language.toolchain_lister()?;
334	let toolchains = language.toolchain_lister()?;	334	Some(toolchains.list(root.to_path_buf(), project_env).await)
335	Some(toolchains.list(root.to_path_buf(), project_env).await)	335	})
336	})	336	.await
337	.await
338	})	337	})
339	}	338	}
340	pub(crate) fn active_toolchain(	339	pub(crate) fn active_toolchain(

crates/project/src/worktree_store.rs+25−25

     FutureExt, SinkExt,
 };
 use git::repository::Branch;
-use gpui::{App, AsyncApp, Context, Entity, EntityId, EventEmitter, Task, WeakEntity};
+use gpui::{
+    App, AppContext as _, AsyncApp, Context, Entity, EntityId, EventEmitter, Task, WeakEntity,
+};
 use postage::oneshot;
 use rpc::{
     proto::{self, FromProto, ToProto, SSH_PROJECT_ID},
             Task::ready(Ok((tree, relative_path)))
         } else {
             let worktree = self.create_worktree(abs_path, visible, cx);
-            cx.background_executor()
+            cx.background_spawn(async move { Ok((worktree.await?, PathBuf::new())) })
-                .spawn(async move { Ok((worktree.await?, PathBuf::new())) })
         }
     }
         let (output_tx, output_rx) = smol::channel::bounded(64);
         let (matching_paths_tx, matching_paths_rx) = smol::channel::unbounded();
-        let input = cx.background_executor().spawn({
+        let input = cx.background_spawn({
             let fs = fs.clone();
             let query = query.clone();
             async move {
             }
         });
         const MAX_CONCURRENT_FILE_SCANS: usize = 64;
-        let filters = cx.background_executor().spawn(async move {
+        let filters = cx.background_spawn(async move {
             let fs = &fs;
             let query = &query;
             executor
                 })
                 .await;
         });
-        cx.background_executor()
+        cx.background_spawn(async move {
-            .spawn(async move {
+            let mut matched = 0;
-                let mut matched = 0;
+            while let Ok(mut receiver) = output_rx.recv().await {
-                while let Ok(mut receiver) = output_rx.recv().await {
+                let Some(path) = receiver.next().await else {
-                    let Some(path) = receiver.next().await else {
+                    continue;
-                        continue;
+                };
-                    };
+                let Ok(_) = matching_paths_tx.send(path).await else {
-                    let Ok(_) = matching_paths_tx.send(path).await else {
+                    break;
-                        break;
+                };
-                    };
+                matched += 1;
-                    matched += 1;
+                if matched == limit {
-                    if matched == limit {
+                    break;
-                        break;
-                    }
                 }
-                drop(input);
+            }
-                drop(filters);
+            drop(input);
-            })
+            drop(filters);
-            .detach();
+        })
+        .detach();
         matching_paths_rx
     }
                     }),
                 });
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     let response = request.await?;
                     let branches = response
                     branch_name: new_branch,
                 });
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     request.await?;
                     Ok(())
                 })

crates/project_panel/src/project_panel.rs+2−3

         mut cx: AsyncWindowContext,
     ) -> Result<Entity<Self>> {
         let serialized_panel = cx
-            .background_executor()
+            .background_spawn(async move { KEY_VALUE_STORE.read_kvp(PROJECT_PANEL_KEY) })
-            .spawn(async move { KEY_VALUE_STORE.read_kvp(PROJECT_PANEL_KEY) })
             .await
             .map_err(|e| anyhow!("Failed to load project panel: {}", e))
             .log_err()
     fn serialize(&mut self, cx: &mut Context<Self>) {
         let width = self.width;
-        self.pending_serialization = cx.background_executor().spawn(
+        self.pending_serialization = cx.background_spawn(
             async move {
                 KEY_VALUE_STORE
                     .write_kvp(

crates/prompt_library/src/prompt_library.rs+1−2

@@ -218,8 +218,7 @@ impl PickerDelegate for PromptPickerDelegate { · 217 unmodified lines
218	let prev_prompt_id = self.matches.get(self.selected_index).map(\|mat\| mat.id);	218	let prev_prompt_id = self.matches.get(self.selected_index).map(\|mat\| mat.id);
219	cx.spawn_in(window, \|this, mut cx\| async move {	219	cx.spawn_in(window, \|this, mut cx\| async move {
220	let (matches, selected_index) = cx	220	let (matches, selected_index) = cx
221	.background_executor()	221	.background_spawn(async move {
222	.spawn(async move {
223	let matches = search.await;	222	let matches = search.await;
224		223
225	let selected_index = prev_prompt_id	224	let selected_index = prev_prompt_id

crates/prompt_library/src/prompts.rs+79−80

@@ -2,7 +2,7 @@ use anyhow::Result; · 1 unmodified line
2	use assets::Assets;	2	use assets::Assets;
3	use fs::Fs;	3	use fs::Fs;
4	use futures::StreamExt;	4	use futures::StreamExt;
5	use gpui::{App, AssetSource};	5	use gpui::{App, AppContext as _, AssetSource};
6	use handlebars::{Handlebars, RenderError};	6	use handlebars::{Handlebars, RenderError};
7	use language::{BufferSnapshot, LanguageName, Point};	7	use language::{BufferSnapshot, LanguageName, Point};
8	use parking_lot::Mutex;	8	use parking_lot::Mutex;
@@ -103,103 +103,102 @@ impl PromptBuilder { · 94 unmodified lines
103	handlebars: Arc<Mutex<Handlebars<'static>>>,	103	handlebars: Arc<Mutex<Handlebars<'static>>>,
104	) {	104	) {
105	let templates_dir = paths::prompt_overrides_dir(params.repo_path.as_deref());	105	let templates_dir = paths::prompt_overrides_dir(params.repo_path.as_deref());
106	params.cx.background_executor()	106	params.cx.background_spawn(async move {
107	.spawn(async move {	107	let Some(parent_dir) = templates_dir.parent() else {
108	let Some(parent_dir) = templates_dir.parent() else {	108	return;
109	return;	109	};
110	};	110
111		111	let mut found_dir_once = false;
112	let mut found_dir_once = false;	112	loop {
113	loop {	113	// Check if the templates directory exists and handle its status
114	// Check if the templates directory exists and handle its status	114	// If it exists, log its presence and check if it's a symlink
115	// If it exists, log its presence and check if it's a symlink	115	// If it doesn't exist:
116	// If it doesn't exist:	116	// - Log that we're using built-in prompts
117	// - Log that we're using built-in prompts	117	// - Check if it's a broken symlink and log if so
118	// - Check if it's a broken symlink and log if so	118	// - Set up a watcher to detect when it's created
119	// - Set up a watcher to detect when it's created	119	// After the first check, set the `found_dir_once` flag
120	// After the first check, set the `found_dir_once` flag	120	// This allows us to avoid logging when looping back around after deleting the prompt overrides directory.
121	// This allows us to avoid logging when looping back around after deleting the prompt overrides directory.	121	let dir_status = params.fs.is_dir(&templates_dir).await;
122	let dir_status = params.fs.is_dir(&templates_dir).await;	122	let symlink_status = params.fs.read_link(&templates_dir).await.ok();
123	let symlink_status = params.fs.read_link(&templates_dir).await.ok();	123	if dir_status {
124	if dir_status {	124	let mut log_message = format!("Prompt template overrides directory found at {}", templates_dir.display());
125	let mut log_message = format!("Prompt template overrides directory found at {}", templates_dir.display());	125	if let Some(target) = symlink_status {
		126	log_message.push_str(" -> ");
		127	log_message.push_str(&target.display().to_string());
		128	}
		129	log::info!("{}.", log_message);
		130	} else {
		131	if !found_dir_once {
		132	log::info!("No prompt template overrides directory found at {}. Using built-in prompts.", templates_dir.display());
126	if let Some(target) = symlink_status {	133	if let Some(target) = symlink_status {
127	log_message.push_str(" -> ");	134	log::info!("Symlink found pointing to {}, but target is invalid.", target.display());
128	log_message.push_str(&target.display().to_string());
129	}
130	log::info!("{}.", log_message);
131	} else {
132	if !found_dir_once {
133	log::info!("No prompt template overrides directory found at {}. Using built-in prompts.", templates_dir.display());
134	if let Some(target) = symlink_status {
135	log::info!("Symlink found pointing to {}, but target is invalid.", target.display());
136	}
137	}	135	}
		136	}
138		137
139	if params.fs.is_dir(parent_dir).await {	138	if params.fs.is_dir(parent_dir).await {
140	let (mut changes, _watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;	139	let (mut changes, _watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
141	while let Some(changed_paths) = changes.next().await {	140	while let Some(changed_paths) = changes.next().await {
142	if changed_paths.iter().any(\|p\| &p.path == &templates_dir) {	141	if changed_paths.iter().any(\|p\| &p.path == &templates_dir) {
143	let mut log_message = format!("Prompt template overrides directory detected at {}", templates_dir.display());	142	let mut log_message = format!("Prompt template overrides directory detected at {}", templates_dir.display());
144	if let Ok(target) = params.fs.read_link(&templates_dir).await {	143	if let Ok(target) = params.fs.read_link(&templates_dir).await {
145	log_message.push_str(" -> ");	144	log_message.push_str(" -> ");
146	log_message.push_str(&target.display().to_string());	145	log_message.push_str(&target.display().to_string());
147	}
148	log::info!("{}.", log_message);
149	break;
150	}	146	}
		147	log::info!("{}.", log_message);
		148	break;
151	}	149	}
152	} else {
153	return;
154	}	150	}
		151	} else {
		152	return;
155	}	153	}
		154	}
156		155
157	found_dir_once = true;	156	found_dir_once = true;
158		157
159	// Initial scan of the prompt overrides directory	158	// Initial scan of the prompt overrides directory
160	if let Ok(mut entries) = params.fs.read_dir(&templates_dir).await {	159	if let Ok(mut entries) = params.fs.read_dir(&templates_dir).await {
161	while let Some(Ok(file_path)) = entries.next().await {	160	while let Some(Ok(file_path)) = entries.next().await {
162	if file_path.to_string_lossy().ends_with(".hbs") {	161	if file_path.to_string_lossy().ends_with(".hbs") {
163	if let Ok(content) = params.fs.load(&file_path).await {	162	if let Ok(content) = params.fs.load(&file_path).await {
164	let file_name = file_path.file_stem().unwrap().to_string_lossy();	163	let file_name = file_path.file_stem().unwrap().to_string_lossy();
165	log::debug!("Registering prompt template override: {}", file_name);	164	log::debug!("Registering prompt template override: {}", file_name);
166	handlebars.lock().register_template_string(&file_name, content).log_err();	165	handlebars.lock().register_template_string(&file_name, content).log_err();
167	}
168	}	166	}
169	}	167	}
170	}	168	}
		169	}
171		170
172	// Watch both the parent directory and the template overrides directory:	171	// Watch both the parent directory and the template overrides directory:
173	// - Monitor the parent directory to detect if the template overrides directory is deleted.	172	// - Monitor the parent directory to detect if the template overrides directory is deleted.
174	// - Monitor the template overrides directory to re-register templates when they change.	173	// - Monitor the template overrides directory to re-register templates when they change.
175	// Combine both watch streams into a single stream.	174	// Combine both watch streams into a single stream.
176	let (parent_changes, parent_watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;	175	let (parent_changes, parent_watcher) = params.fs.watch(parent_dir, Duration::from_secs(1)).await;
177	let (changes, watcher) = params.fs.watch(&templates_dir, Duration::from_secs(1)).await;	176	let (changes, watcher) = params.fs.watch(&templates_dir, Duration::from_secs(1)).await;
178	let mut combined_changes = futures::stream::select(changes, parent_changes);	177	let mut combined_changes = futures::stream::select(changes, parent_changes);
179		178
180	while let Some(changed_paths) = combined_changes.next().await {	179	while let Some(changed_paths) = combined_changes.next().await {
181	if changed_paths.iter().any(\|p\| &p.path == &templates_dir) {	180	if changed_paths.iter().any(\|p\| &p.path == &templates_dir) {
182	if !params.fs.is_dir(&templates_dir).await {	181	if !params.fs.is_dir(&templates_dir).await {
183	log::info!("Prompt template overrides directory removed. Restoring built-in prompt templates.");	182	log::info!("Prompt template overrides directory removed. Restoring built-in prompt templates.");
184	Self::register_built_in_templates(&mut handlebars.lock()).log_err();	183	Self::register_built_in_templates(&mut handlebars.lock()).log_err();
185	break;	184	break;
186	}
187	}	185	}
188	for event in changed_paths {	186	}
189	if event.path.starts_with(&templates_dir) && event.path.extension().map_or(false, \|ext\| ext == "hbs") {	187	for event in changed_paths {
190	log::info!("Reloading prompt template override: {}", event.path.display());	188	if event.path.starts_with(&templates_dir) && event.path.extension().map_or(false, \|ext\| ext == "hbs") {
191	if let Some(content) = params.fs.load(&event.path).await.log_err() {	189	log::info!("Reloading prompt template override: {}", event.path.display());
192	let file_name = event.path.file_stem().unwrap().to_string_lossy();	190	if let Some(content) = params.fs.load(&event.path).await.log_err() {
193	handlebars.lock().register_template_string(&file_name, content).log_err();	191	let file_name = event.path.file_stem().unwrap().to_string_lossy();
194	}	192	handlebars.lock().register_template_string(&file_name, content).log_err();
195	}	193	}
196	}	194	}
197	}	195	}
198
199	drop(watcher);
200	drop(parent_watcher);
201	}	196	}
202	})	197
		198	drop(watcher);
		199	drop(parent_watcher);
		200	}
		201	})
203	.detach();	202	.detach();
204	}	203	}
205		204

crates/remote/src/ssh_session.rs+12−13

     select, select_biased, AsyncReadExt as _, Future, FutureExt as _, StreamExt as _,
 };
 use gpui::{
-    App, AppContext, AsyncApp, BorrowAppContext, Context, Entity, EventEmitter, Global,
+    App, AppContext as _, AsyncApp, BorrowAppContext, Context, Entity, EventEmitter, Global,
     SemanticVersion, Task, WeakEntity,
 };
 use itertools::Itertools;
                 c.connections.insert(
                     opts.clone(),
                     ConnectionPoolEntry::Connecting(
-                        cx.background_executor()
+                        cx.background_spawn({
-                            .spawn({
+                            let connection = connection.clone();
-                                let connection = connection.clone();
+                            async move { Ok(connection.clone()) }
-                                async move { Ok(connection.clone()) }
+                        })
-                            })
+                        .shared(),
-                            .shared(),
                     ),
                 );
             })
             ))
             .output();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let output = output.await?;
             if !output.status.success() {
         let mut stderr_buffer = Vec::new();
         let mut stderr_offset = 0;
-        let stdin_task = cx.background_executor().spawn(async move {
+        let stdin_task = cx.background_spawn(async move {
             while let Some(outgoing) = outgoing_rx.next().await {
                 write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
             }
             anyhow::Ok(())
         });
-        let stdout_task = cx.background_executor().spawn({
+        let stdout_task = cx.background_spawn({
             let mut connection_activity_tx = connection_activity_tx.clone();
             async move {
                 loop {
             }
         });
-        let stderr_task: Task<anyhow::Result<()>> = cx.background_executor().spawn(async move {
+        let stderr_task: Task<anyhow::Result<()>> = cx.background_spawn(async move {
             loop {
                 stderr_buffer.resize(stderr_offset + 1024, 0);
         },
         select_biased, FutureExt, SinkExt, StreamExt,
     };
-    use gpui::{App, AsyncApp, SemanticVersion, Task, TestAppContext};
+    use gpui::{App, AppContext as _, AsyncApp, SemanticVersion, Task, TestAppContext};
     use release_channel::ReleaseChannel;
     use rpc::proto::Envelope;
                 &self.server_cx.get(cx),
             );
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 loop {
                     select_biased! {
                         server_to_client = server_outgoing_rx.next().fuse() => {

crates/remote_server/src/headless_project.rs+9−11

                 operation,
                 is_local: true,
             } => cx
-                .background_executor()
+                .background_spawn(self.session.request(proto::UpdateBuffer {
-                .spawn(self.session.request(proto::UpdateBuffer {
                     project_id: SSH_PROJECT_ID,
                     buffer_id: buffer.read(cx).remote_id().to_proto(),
                     operations: vec![serialize_operation(operation)],
                     message: prompt.message.clone(),
                 });
                 let prompt = prompt.clone();
-                cx.background_executor()
+                cx.background_spawn(async move {
-                    .spawn(async move {
+                    let response = request.await?;
-                        let response = request.await?;
+                    if let Some(action_response) = response.action_response {
-                        if let Some(action_response) = response.action_response {
+                        prompt.respond(action_response as usize).await;
-                            prompt.respond(action_response as usize).await;
+                    }
-                        }
+                    anyhow::Ok(())
-                        anyhow::Ok(())
+                })
-                    })
+                .detach();
-                    .detach();
             }
             _ => {}
         }

crates/remote_server/src/unix.rs+2−3

             let mut output_buffer = Vec::new();
             let (mut stdin_msg_tx, mut stdin_msg_rx) = mpsc::unbounded::<Envelope>();
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 while let Ok(msg) = read_message(&mut stdin_stream, &mut input_buffer).await {
                     if let Err(_) = stdin_msg_tx.send(msg).await {
                         break;
         handle_panic_requests(&project, &session);
-        cx.background_executor()
+        cx.background_spawn(async move { cleanup_old_binaries() })
-            .spawn(async move { cleanup_old_binaries() })
             .detach();
         mem::forget(project);

crates/repl/src/kernels/native_kernel.rs+4−4

@@ -5,7 +5,7 @@ use futures::{ · 4 unmodified lines
5	stream::{SelectAll, StreamExt},	5	stream::{SelectAll, StreamExt},
6	AsyncBufReadExt as _, SinkExt as _,	6	AsyncBufReadExt as _, SinkExt as _,
7	};	7	};
8	use gpui::{App, Entity, EntityId, Task, Window};	8	use gpui::{App, AppContext as _, Entity, EntityId, Task, Window};
9	use jupyter_protocol::{	9	use jupyter_protocol::{
10	connection_info::{ConnectionInfo, Transport},	10	connection_info::{ConnectionInfo, Transport},
11	ExecutionState, JupyterKernelspec, JupyterMessage, JupyterMessageContent, KernelInfoReply,	11	ExecutionState, JupyterKernelspec, JupyterMessage, JupyterMessageContent, KernelInfoReply,
@@ -211,7 +211,7 @@ impl NativeRunningKernel { · 199 unmodified lines
211	futures::channel::mpsc::channel(100);	211	futures::channel::mpsc::channel(100);
212	let (mut shell_request_tx, mut shell_request_rx) = futures::channel::mpsc::channel(100);	212	let (mut shell_request_tx, mut shell_request_rx) = futures::channel::mpsc::channel(100);
213		213
214	let routing_task = cx.background_executor().spawn({	214	let routing_task = cx.background_spawn({
215	async move {	215	async move {
216	while let Some(message) = request_rx.next().await {	216	while let Some(message) = request_rx.next().await {
217	match message.content {	217	match message.content {
@@ -229,7 +229,7 @@ impl NativeRunningKernel { · 11 unmodified lines
229	}	229	}
230	});	230	});
231		231
232	let shell_task = cx.background_executor().spawn({	232	let shell_task = cx.background_spawn({
233	async move {	233	async move {
234	while let Some(message) = shell_request_rx.next().await {	234	while let Some(message) = shell_request_rx.next().await {
235	shell_socket.send(message).await.ok();	235	shell_socket.send(message).await.ok();
@@ -240,7 +240,7 @@ impl NativeRunningKernel { · 4 unmodified lines
240	}	240	}
241	});	241	});
242		242
243	let control_task = cx.background_executor().spawn({	243	let control_task = cx.background_spawn({
244	async move {	244	async move {
245	while let Some(message) = control_request_rx.next().await {	245	while let Some(message) = control_request_rx.next().await {
246	control_socket.send(message).await.ok();	246	control_socket.send(message).await.ok();

crates/repl/src/kernels/remote_kernels.rs+2−2

@@ -1,5 +1,5 @@
1	use futures::{channel::mpsc, SinkExt as _};	1	use futures::{channel::mpsc, SinkExt as _};
2	use gpui::{App, Entity, Task, Window};	2	use gpui::{App, AppContext as _, Entity, Task, Window};
3	use http_client::{AsyncBody, HttpClient, Request};	3	use http_client::{AsyncBody, HttpClient, Request};
4	use jupyter_protocol::{ExecutionState, JupyterKernelspec, JupyterMessage, KernelInfoReply};	4	use jupyter_protocol::{ExecutionState, JupyterKernelspec, JupyterMessage, KernelInfoReply};
5		5
@@ -189,7 +189,7 @@ impl RemoteRunningKernel { · 183 unmodified lines
189	let (request_tx, mut request_rx) =	189	let (request_tx, mut request_rx) =
190	futures::channel::mpsc::channel::<JupyterMessage>(100);	190	futures::channel::mpsc::channel::<JupyterMessage>(100);
191		191
192	let routing_task = cx.background_executor().spawn({	192	let routing_task = cx.background_spawn({
193	async move {	193	async move {
194	while let Some(message) = request_rx.next().await {	194	while let Some(message) = request_rx.next().await {
195	w.send(message).await.ok();	195	w.send(message).await.ok();

crates/repl/src/notebook/cell.rs+1−2

@@ -134,8 +134,7 @@ impl Cell { · 133 unmodified lines
134		134
135	cx.spawn_in(window, \|this, mut cx\| async move {	135	cx.spawn_in(window, \|this, mut cx\| async move {
136	let parsed_markdown = cx	136	let parsed_markdown = cx
137	.background_executor()	137	.background_spawn(async move {
138	.spawn(async move {
139	parse_markdown(&source, None, Some(languages)).await	138	parse_markdown(&source, None, Some(languages)).await
140	})	139	})
141	.await;	140	.await;

crates/repl/src/outputs/markdown.rs+2−3

     pub fn from(text: String, cx: &mut Context<Self>) -> Self {
         let task = cx.spawn(|markdown_view, mut cx| {
             let text = text.clone();
-            let parsed = cx
+            let parsed =
-                .background_executor()
+                cx.background_spawn(async move { parse_markdown(&text, None, None).await });
-                .spawn(async move { parse_markdown(&text, None, None).await });
             async move {
                 let content = parsed.await;

crates/repl/src/repl_store.rs+1−1

@@ -164,7 +164,7 @@ impl ReplStore { · 163 unmodified lines
164		164
165	let remote_kernel_specifications = self.get_remote_kernel_specifications(cx);	165	let remote_kernel_specifications = self.get_remote_kernel_specifications(cx);
166		166
167	let all_specs = cx.background_executor().spawn(async move {	167	let all_specs = cx.background_spawn(async move {
168	let mut all_specs = local_kernel_specifications	168	let mut all_specs = local_kernel_specifications
169	.await?	169	.await?
170	.into_iter()	170	.into_iter()

crates/semantic_index/src/embedding_index.rs+7−7

@@ -10,7 +10,7 @@ use fs::Fs; · 9 unmodified lines
10	use fs::MTime;	10	use fs::MTime;
11	use futures::{stream::StreamExt, FutureExt as _};	11	use futures::{stream::StreamExt, FutureExt as _};
12	use futures_batch::ChunksTimeoutStreamExt;	12	use futures_batch::ChunksTimeoutStreamExt;
13	use gpui::{App, Entity, Task};	13	use gpui::{App, AppContext as _, Entity, Task};
14	use heed::types::{SerdeBincode, Str};	14	use heed::types::{SerdeBincode, Str};
15	use language::LanguageRegistry;	15	use language::LanguageRegistry;
16	use log;	16	use log;
@@ -102,7 +102,7 @@ impl EmbeddingIndex { · 85 unmodified lines
102	let db_connection = self.db_connection.clone();	102	let db_connection = self.db_connection.clone();
103	let db = self.db;	103	let db = self.db;
104	let entries_being_indexed = self.entry_ids_being_indexed.clone();	104	let entries_being_indexed = self.entry_ids_being_indexed.clone();
105	let task = cx.background_executor().spawn(async move {	105	let task = cx.background_spawn(async move {
106	let txn = db_connection	106	let txn = db_connection
107	.read_txn()	107	.read_txn()
108	.context("failed to create read transaction")?;	108	.context("failed to create read transaction")?;
@@ -185,7 +185,7 @@ impl EmbeddingIndex { · 76 unmodified lines
185	let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);	185	let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
186	let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);	186	let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
187	let entries_being_indexed = self.entry_ids_being_indexed.clone();	187	let entries_being_indexed = self.entry_ids_being_indexed.clone();
188	let task = cx.background_executor().spawn(async move {	188	let task = cx.background_spawn(async move {
189	for (path, entry_id, status) in updated_entries.iter() {	189	for (path, entry_id, status) in updated_entries.iter() {
190	match status {	190	match status {
191	project::PathChange::Added	191	project::PathChange::Added
@@ -278,7 +278,7 @@ impl EmbeddingIndex { · 86 unmodified lines
278	) -> EmbedFiles {	278	) -> EmbedFiles {
279	let embedding_provider = embedding_provider.clone();	279	let embedding_provider = embedding_provider.clone();
280	let (embedded_files_tx, embedded_files_rx) = channel::bounded(512);	280	let (embedded_files_tx, embedded_files_rx) = channel::bounded(512);
281	let task = cx.background_executor().spawn(async move {	281	let task = cx.background_spawn(async move {
282	let mut chunked_file_batches =	282	let mut chunked_file_batches =
283	pin!(chunked_files.chunks_timeout(512, Duration::from_secs(2)));	283	pin!(chunked_files.chunks_timeout(512, Duration::from_secs(2)));
284	while let Some(chunked_files) = chunked_file_batches.next().await {	284	while let Some(chunked_files) = chunked_file_batches.next().await {
@@ -361,7 +361,7 @@ impl EmbeddingIndex { · 76 unmodified lines
361	let db_connection = self.db_connection.clone();	361	let db_connection = self.db_connection.clone();
362	let db = self.db;	362	let db = self.db;
363		363
364	cx.background_executor().spawn(async move {	364	cx.background_spawn(async move {
365	let mut deleted_entry_ranges = pin!(deleted_entry_ranges);	365	let mut deleted_entry_ranges = pin!(deleted_entry_ranges);
366	let mut embedded_files = pin!(embedded_files);	366	let mut embedded_files = pin!(embedded_files);
367	loop {	367	loop {
@@ -397,7 +397,7 @@ impl EmbeddingIndex { · 29 unmodified lines
397	pub fn paths(&self, cx: &App) -> Task<Result<Vec<Arc<Path>>>> {	397	pub fn paths(&self, cx: &App) -> Task<Result<Vec<Arc<Path>>>> {
398	let connection = self.db_connection.clone();	398	let connection = self.db_connection.clone();
399	let db = self.db;	399	let db = self.db;
400	cx.background_executor().spawn(async move {	400	cx.background_spawn(async move {
401	let tx = connection	401	let tx = connection
402	.read_txn()	402	.read_txn()
403	.context("failed to create read transaction")?;	403	.context("failed to create read transaction")?;
@@ -413,7 +413,7 @@ impl EmbeddingIndex { · 9 unmodified lines
413	pub fn chunks_for_path(&self, path: Arc<Path>, cx: &App) -> Task<Result<Vec<EmbeddedChunk>>> {	413	pub fn chunks_for_path(&self, path: Arc<Path>, cx: &App) -> Task<Result<Vec<EmbeddedChunk>>> {
414	let connection = self.db_connection.clone();	414	let connection = self.db_connection.clone();
415	let db = self.db;	415	let db = self.db;
416	cx.background_executor().spawn(async move {	416	cx.background_spawn(async move {
417	let tx = connection	417	let tx = connection
418	.read_txn()	418	.read_txn()
419	.context("failed to create read transaction")?;	419	.context("failed to create read transaction")?;

crates/semantic_index/src/project_index.rs+8−5

 use collections::HashMap;
 use fs::Fs;
 use futures::FutureExt;
-use gpui::{App, Context, Entity, EntityId, EventEmitter, Subscription, Task, WeakEntity};
+use gpui::{
+    App, AppContext as _, Context, Entity, EntityId, EventEmitter, Subscription, Task, WeakEntity,
+};
 use language::LanguageRegistry;
 use log;
 use project::{Project, Worktree, WorktreeId};
                         let worktree_id = index.worktree().read(cx).id();
                         let db_connection = index.db_connection().clone();
                         let db = *index.embedding_index().db();
-                        cx.background_executor().spawn(async move {
+                        cx.background_spawn(async move {
                             let txn = db_connection
                                 .read_txn()
                                 .context("failed to create read transaction")?;
                         let file_digest_db = summary_index.file_digest_db();
                         let summary_db = summary_index.summary_db();
-                        cx.background_executor().spawn(async move {
+                        cx.background_spawn(async move {
                             let txn = db_connection
                                 .read_txn()
                                 .context("failed to create db read transaction")?;
                 index
                     .read_with(&cx, |index, cx| {
-                        cx.background_executor()
+                        cx.background_spawn(
-                            .spawn(index.summary_index().flush_backlog(worktree_abs_path, cx))
+                            index.summary_index().flush_backlog(worktree_abs_path, cx),
+                        )
                     })?
                     .await
             })

crates/semantic_index/src/semantic_index.rs+2−4

         cx: &mut AsyncApp,
     ) -> Result<Self> {
         let db_connection = cx
-            .background_executor()
+            .background_spawn(async move {
-            .spawn(async move {
                 std::fs::create_dir_all(&db_path)?;
                 unsafe {
                     heed::EnvOpenOptions::new()
                 let worktree = search_result.worktree.read(cx);
                 let entry_abs_path = worktree.abs_path().join(&search_result.path);
                 let fs = project.read(cx).fs().clone();
-                cx.background_executor()
+                cx.background_spawn(async move { fs.load(&entry_abs_path).await.unwrap() })
-                    .spawn(async move { fs.load(&entry_abs_path).await.unwrap() })
             })
             .await;

crates/semantic_index/src/summary_index.rs+28−29

 use fs::{Fs, MTime};
 use futures::{stream::StreamExt, TryFutureExt};
 use futures_batch::ChunksTimeoutStreamExt;
-use gpui::{App, Entity, Task};
+use gpui::{App, AppContext as _, Entity, Task};
 use heed::{
     types::{SerdeBincode, Str},
     RoTxn,
         let db_connection = self.db_connection.clone();
         let db = self.summary_db;
         let (needs_summary_tx, needs_summary_rx) = channel::bounded(512);
-        let task = cx.background_executor().spawn(async move {
+        let task = cx.background_spawn(async move {
             let mut might_need_summary = pin!(might_need_summary);
             while let Some(file) = might_need_summary.next().await {
                 let tx = db_connection
         let db_connection = self.db_connection.clone();
         let digest_db = self.file_digest_db;
         let backlog = Arc::clone(&self.backlog);
-        let task = cx.background_executor().spawn(async move {
+        let task = cx.background_spawn(async move {
             let txn = db_connection
                 .read_txn()
                 .context("failed to create read transaction")?;
         let db_connection = self.db_connection.clone();
         let digest_db = self.file_digest_db;
         let backlog = Arc::clone(&self.backlog);
-        let task = cx.background_executor().spawn(async move {
+        let task = cx.background_spawn(async move {
             let txn = db_connection
                 .read_txn()
                 .context("failed to create read transaction")?;
             .available_models(cx)
             .find(|model| &model.id() == &summary_model_id)
         else {
-            return cx.background_executor().spawn(async move {
+            return cx.background_spawn(async move {
                 Err(anyhow!("Couldn't find the preferred summarization model ({:?}) in the language registry's available models", summary_model_id))
             });
         };
         let code_len = code.len();
         cx.spawn(|cx| async move {
             let stream = model.stream_completion(request, &cx);
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                let answer: String = stream
-                    let answer: String = stream
+                    .await?
-                        .await?
+                    .filter_map(|event| async {
-                        .filter_map(|event| async {
+                        if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
-                            if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
+                            Some(text)
-                                Some(text)
+                        } else {
-                            } else {
+                            None
-                                None
+                        }
-                            }
+                    })
-                        })
+                    .collect()
-                        .collect()
+                    .await;
-                        .await;
-                    log::info!(
+                log::info!(
-                        "It took {:?} to summarize {:?} bytes of code.",
+                    "It took {:?} to summarize {:?} bytes of code.",
-                        start.elapsed(),
+                    start.elapsed(),
-                        code_len
+                    code_len
-                    );
+                );
-                    log::debug!("Summary was: {:?}", &answer);
+                log::debug!("Summary was: {:?}", &answer);
-                    Ok(answer)
+                Ok(answer)
-                })
+            })
-                .await
+            .await
             // TODO if summarization failed, put it back in the backlog!
         })
         let db_connection = self.db_connection.clone();
         let digest_db = self.file_digest_db;
         let summary_db = self.summary_db;
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let mut summaries = pin!(summaries.chunks_timeout(4096, Duration::from_secs(2)));
             while let Some(summaries) = summaries.next().await {
                 let mut txn = db_connection.write_txn()?;
                 backlog.drain().collect()
             };
-            let task = cx.background_executor().spawn(async move {
+            let task = cx.background_spawn(async move {
                 tx.send(needs_summary).await?;
                 Ok(())
             });

crates/semantic_index/src/worktree_index.rs+1−2

         cx.spawn(|mut cx| async move {
             let entries_being_indexed = Arc::new(IndexingEntrySet::new(status_tx));
             let (embedding_index, summary_index) = cx
-                .background_executor()
+                .background_spawn({
-                .spawn({
                     let entries_being_indexed = Arc::clone(&entries_being_indexed);
                     let db_connection = db_connection.clone();
                     async move {

crates/session/src/session.rs+2−2

@@ -1,7 +1,7 @@
1	use std::time::Duration;	1	use std::time::Duration;
2		2
3	use db::kvp::KEY_VALUE_STORE;	3	use db::kvp::KEY_VALUE_STORE;
4	use gpui::{AnyWindowHandle, Context, Subscription, Task, WindowId};	4	use gpui::{AnyWindowHandle, AppContext as _, Context, Subscription, Task, WindowId};
5	use util::ResultExt;	5	use util::ResultExt;
6	use uuid::Uuid;	6	use uuid::Uuid;
7		7
@@ -88,7 +88,7 @@ impl AppSession { · 80 unmodified lines
88		88
89	fn app_will_quit(&mut self, cx: &mut Context<Self>) -> Task<()> {	89	fn app_will_quit(&mut self, cx: &mut Context<Self>) -> Task<()> {
90	if let Some(windows) = cx.window_stack() {	90	if let Some(windows) = cx.window_stack() {
91	cx.background_executor().spawn(store_window_stack(windows))	91	cx.background_spawn(store_window_stack(windows))
92	} else {	92	} else {
93	Task::ready(())	93	Task::ready(())
94	}	94	}

crates/task/src/static_source.rs+52−54

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	use std::sync::Arc;	3	use std::sync::Arc;
4		4
5	use futures::{channel::mpsc::UnboundedSender, StreamExt};	5	use futures::{channel::mpsc::UnboundedSender, StreamExt};
6	use gpui::App;	6	use gpui::{App, AppContext};
7	use parking_lot::RwLock;	7	use parking_lot::RwLock;
8	use serde::Deserialize;	8	use serde::Deserialize;
9	use util::ResultExt;	9	use util::ResultExt;
@@ -33,35 +33,34 @@ impl<T: PartialEq + 'static + Sync> TrackedFile<T> { · 23 unmodified lines
33	T: for<'a> Deserialize<'a> + Default + Send,	33	T: for<'a> Deserialize<'a> + Default + Send,
34	{	34	{
35	let parsed_contents: Arc<RwLock<T>> = Arc::default();	35	let parsed_contents: Arc<RwLock<T>> = Arc::default();
36	cx.background_executor()	36	cx.background_spawn({
37	.spawn({	37	let parsed_contents = parsed_contents.clone();
38	let parsed_contents = parsed_contents.clone();	38	async move {
39	async move {	39	while let Some(new_contents) = tracker.next().await {
40	while let Some(new_contents) = tracker.next().await {	40	if Arc::strong_count(&parsed_contents) == 1 {
41	if Arc::strong_count(&parsed_contents) == 1 {	41	// We're no longer being observed. Stop polling.
42	// We're no longer being observed. Stop polling.	42	break;
43	break;	43	}
44	}	44	if !new_contents.trim().is_empty() {
45	if !new_contents.trim().is_empty() {	45	let Some(new_contents) =
46	let Some(new_contents) =	46	serde_json_lenient::from_str::<T>(&new_contents).log_err()
47	serde_json_lenient::from_str::<T>(&new_contents).log_err()	47	else {
48	else {	48	continue;
49	continue;	49	};
50	};	50	let mut contents = parsed_contents.write();
51	let mut contents = parsed_contents.write();	51	if *contents != new_contents {
52	if *contents != new_contents {	52	*contents = new_contents;
53	*contents = new_contents;	53	if notification_outlet.unbounded_send(()).is_err() {
54	if notification_outlet.unbounded_send(()).is_err() {	54	// Whoever cared about contents is not around anymore.
55	// Whoever cared about contents is not around anymore.	55	break;
56	break;
57	}
58	}	56	}
59	}	57	}
60	}	58	}
61	anyhow::Ok(())
62	}	59	}
63	})	60	anyhow::Ok(())
64	.detach_and_log_err(cx);	61	}
		62	})
		63	.detach_and_log_err(cx);
65	Self { parsed_contents }	64	Self { parsed_contents }
66	}	65	}
67		66
@@ -75,39 +74,38 @@ impl<T: PartialEq + 'static + Sync> TrackedFile<T> { · 7 unmodified lines
75	T: Default + Send,	74	T: Default + Send,
76	{	75	{
77	let parsed_contents: Arc<RwLock<T>> = Arc::default();	76	let parsed_contents: Arc<RwLock<T>> = Arc::default();
78	cx.background_executor()	77	cx.background_spawn({
79	.spawn({	78	let parsed_contents = parsed_contents.clone();
80	let parsed_contents = parsed_contents.clone();	79	async move {
81	async move {	80	while let Some(new_contents) = tracker.next().await {
82	while let Some(new_contents) = tracker.next().await {	81	if Arc::strong_count(&parsed_contents) == 1 {
83	if Arc::strong_count(&parsed_contents) == 1 {	82	// We're no longer being observed. Stop polling.
84	// We're no longer being observed. Stop polling.	83	break;
85	break;	84	}
86	}
87		85
88	if !new_contents.trim().is_empty() {	86	if !new_contents.trim().is_empty() {
89	let Some(new_contents) =	87	let Some(new_contents) =
90	serde_json_lenient::from_str::<U>(&new_contents).log_err()	88	serde_json_lenient::from_str::<U>(&new_contents).log_err()
91	else {	89	else {
92	continue;	90	continue;
93	};	91	};
94	let Some(new_contents) = new_contents.try_into().log_err() else {	92	let Some(new_contents) = new_contents.try_into().log_err() else {
95	continue;	93	continue;
96	};	94	};
97	let mut contents = parsed_contents.write();	95	let mut contents = parsed_contents.write();
98	if *contents != new_contents {	96	if *contents != new_contents {
99	*contents = new_contents;	97	*contents = new_contents;
100	if notification_outlet.unbounded_send(()).is_err() {	98	if notification_outlet.unbounded_send(()).is_err() {
101	// Whoever cared about contents is not around anymore.	99	// Whoever cared about contents is not around anymore.
102	break;	100	break;
103	}
104	}	101	}
105	}	102	}
106	}	103	}
107	anyhow::Ok(())
108	}	104	}
109	})	105	anyhow::Ok(())
110	.detach_and_log_err(cx);	106	}
		107	})
		108	.detach_and_log_err(cx);
111	Self {	109	Self {
112	parsed_contents: Default::default(),	110	parsed_contents: Default::default(),
113	}	111	}

crates/terminal/src/terminal.rs+4−4

@@ -58,9 +58,9 @@ use std::{ · 57 unmodified lines
58	use thiserror::Error;	58	use thiserror::Error;
59		59
60	use gpui::{	60	use gpui::{
61	actions, black, px, AnyWindowHandle, App, Bounds, ClipboardItem, Context, EventEmitter, Hsla,	61	actions, black, px, AnyWindowHandle, App, AppContext as _, Bounds, ClipboardItem, Context,
62	Keystroke, Modifiers, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, Point,	62	EventEmitter, Hsla, Keystroke, Modifiers, MouseButton, MouseDownEvent, MouseMoveEvent,
63	Rgba, ScrollWheelEvent, SharedString, Size, Task, TouchPhase,	63	MouseUpEvent, Pixels, Point, Rgba, ScrollWheelEvent, SharedString, Size, Task, TouchPhase,
64	};	64	};
65		65
66	use crate::mappings::{colors::to_alac_rgb, keys::to_esc_str};	66	use crate::mappings::{colors::to_alac_rgb, keys::to_esc_str};
@@ -1633,7 +1633,7 @@ impl Terminal { · 1566 unmodified lines
1633	cx: &Context<Self>,	1633	cx: &Context<Self>,
1634	) -> Task<Vec<RangeInclusive<AlacPoint>>> {	1634	) -> Task<Vec<RangeInclusive<AlacPoint>>> {
1635	let term = self.term.clone();	1635	let term = self.term.clone();
1636	cx.background_executor().spawn(async move {	1636	cx.background_spawn(async move {
1637	let term = term.lock();	1637	let term = term.lock();
1638		1638
1639	all_search_matches(&term, &mut searcher).collect()	1639	all_search_matches(&term, &mut searcher).collect()

crates/terminal_view/src/terminal_panel.rs+19−21

@@ -222,8 +222,7 @@ impl TerminalPanel { · 221 unmodified lines
222	mut cx: AsyncWindowContext,	222	mut cx: AsyncWindowContext,
223	) -> Result<Entity<Self>> {	223	) -> Result<Entity<Self>> {
224	let serialized_panel = cx	224	let serialized_panel = cx
225	.background_executor()	225	.background_spawn(async move { KEY_VALUE_STORE.read_kvp(TERMINAL_PANEL_KEY) })
226	.spawn(async move { KEY_VALUE_STORE.read_kvp(TERMINAL_PANEL_KEY) })
227	.await	226	.await
228	.log_err()	227	.log_err()
229	.flatten()	228	.flatten()
@@ -742,25 +741,24 @@ impl TerminalPanel { · 512 unmodified lines
742	))	741	))
743	})	742	})
744	.ok()?;	743	.ok()?;
745	cx.background_executor()	744	cx.background_spawn(
746	.spawn(	745	async move {
747	async move {	746	KEY_VALUE_STORE
748	KEY_VALUE_STORE	747	.write_kvp(
749	.write_kvp(	748	TERMINAL_PANEL_KEY.into(),
750	TERMINAL_PANEL_KEY.into(),	749	serde_json::to_string(&SerializedTerminalPanel {
751	serde_json::to_string(&SerializedTerminalPanel {	750	items,
752	items,	751	active_item_id: None,
753	active_item_id: None,	752	height,
754	height,	753	width,
755	width,	754	})?,
756	})?,	755	)
757	)	756	.await?;
758	.await?;	757	anyhow::Ok(())
759	anyhow::Ok(())	758	}
760	}	759	.log_err(),
761	.log_err(),	760	)
762	)	761	.await;
763	.await;
764	Some(())	762	Some(())
765	});	763	});
766	}	764	}

crates/terminal_view/src/terminal_view.rs+8−5

     potential_paths: HashSet<PathBuf>,
     cx: &mut Context<TerminalView>,
 ) -> Task<Vec<(PathWithPosition, Metadata)>> {
-    cx.background_executor().spawn(async move {
+    cx.background_spawn(async move {
         let mut canonical_paths = HashSet::default();
         for path in potential_paths {
             if let Ok(canonical) = fs.canonicalize(&path).await {
     ) {
         if self.terminal().read(cx).task().is_none() {
             if let Some((new_id, old_id)) = workspace.database_id().zip(self.workspace_id) {
-                cx.background_executor()
+                cx.background_spawn(TERMINAL_DB.update_workspace_id(
-                    .spawn(TERMINAL_DB.update_workspace_id(new_id, old_id, cx.entity_id().as_u64()))
+                    new_id,
-                    .detach();
+                    old_id,
+                    cx.entity_id().as_u64(),
+                ))
+                .detach();
             }
             self.workspace_id = workspace.database_id();
         }
         }
         if let Some((cwd, workspace_id)) = terminal.working_directory().zip(self.workspace_id) {
-            Some(cx.background_executor().spawn(async move {
+            Some(cx.background_spawn(async move {
                 TERMINAL_DB
                     .save_working_directory(item_id, workspace_id, cwd)
                     .await

crates/vim/src/command.rs+11−14

     scroll::Autoscroll,
     Bias, Editor, ToPoint,
 };
-use gpui::{actions, impl_internal_actions, Action, App, Context, Global, Window};
+use gpui::{actions, impl_internal_actions, Action, App, AppContext as _, Context, Global, Window};
 use itertools::Itertools;
 use language::Point;
 use multi_buffer::MultiBufferRow;
                     .clip_point(Point::new(range.end.0 + 1, 0), Bias::Left);
             cx.spawn_in(window, |editor, mut cx| async move {
                 let new_selections = cx
-                    .background_executor()
+                    .background_spawn(async move {
-                    .spawn(async move {
                         let mut line = String::new();
                         let mut new_selections = Vec::new();
                         let chunks = snapshot
             if let Some(mut stdin) = running.stdin.take() {
                 if let Some(snapshot) = input_snapshot {
                     let range = range.clone();
-                    cx.background_executor()
+                    cx.background_spawn(async move {
-                        .spawn(async move {
+                        for chunk in snapshot.text_for_range(range) {
-                            for chunk in snapshot.text_for_range(range) {
+                            if stdin.write_all(chunk.as_bytes()).log_err().is_none() {
-                                if stdin.write_all(chunk.as_bytes()).log_err().is_none() {
+                                return;
-                                    return;
-                                }
                             }
-                            stdin.flush().log_err();
+                        }
-                        })
+                        stdin.flush().log_err();
-                        .detach();
+                    })
+                    .detach();
                 }
             };
             let output = cx
-                .background_executor()
+                .background_spawn(async move { running.wait_with_output() })
-                .spawn(async move { running.wait_with_output() })
                 .await;
             let Some(output) = output.log_err() else {

crates/workspace/src/shared_screen/cross_platform.rs+1−1

@@ -5,7 +5,7 @@ use crate::{ · 4 unmodified lines
5	use call::{RemoteVideoTrack, RemoteVideoTrackView};	5	use call::{RemoteVideoTrack, RemoteVideoTrackView};
6	use client::{proto::PeerId, User};	6	use client::{proto::PeerId, User};
7	use gpui::{	7	use gpui::{
8	div, AppContext, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement,	8	div, AppContext as _, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement,
9	ParentElement, Render, SharedString, Styled,	9	ParentElement, Render, SharedString, Styled,
10	};	10	};
11	use std::sync::Arc;	11	use std::sync::Arc;

crates/workspace/src/workspace.rs+4−7

             self.update_active_view_for_followers(window, cx);
             if let Some(database_id) = self.database_id {
-                cx.background_executor()
+                cx.background_spawn(persistence::DB.update_timestamp(database_id))
-                    .spawn(persistence::DB.update_timestamp(database_id))
                     .detach();
             }
         } else {
                 if let Ok(Some(task)) = this.update_in(cx, |workspace, window, cx| {
                     item.serialize(workspace, false, window, cx)
                 }) {
-                    cx.background_executor()
+                    cx.background_spawn(async move { task.await.log_err() })
-                        .spawn(async move { task.await.log_err() })
                         .detach();
                 }
             }
     ) {
         self.centered_layout = !self.centered_layout;
         if let Some(database_id) = self.database_id() {
-            cx.background_executor()
+            cx.background_spawn(DB.set_centered_layout(database_id, self.centered_layout))
-                .spawn(DB.set_centered_layout(database_id, self.centered_layout))
                 .detach_and_log_err(cx);
         }
         cx.notify();
         Option<SerializedWorkspace>,
     )>,
 > {
-    cx.background_executor().spawn(async move {
+    cx.background_spawn(async move {
         let serialized_ssh_project = persistence::DB
             .get_or_create_ssh_project(
                 connection_options.host.clone(),

crates/worktree/src/worktree.rs+53−58

             // Apply updates to a separate snapshot in a background task, then
             // send them to a foreground task which updates the model.
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                while let Some(update) = background_updates_rx.next().await {
-                    while let Some(update) = background_updates_rx.next().await {
+                    {
+                        let mut lock = background_snapshot.lock();
+                        if let Err(error) = lock
+                            .0
+                            .apply_remote_update(update.clone(), &settings.file_scan_inclusions)
                         {
-                            let mut lock = background_snapshot.lock();
+                            log::error!("error applying worktree update: {}", error);
-                            if let Err(error) = lock
-                                .0
-                                .apply_remote_update(update.clone(), &settings.file_scan_inclusions)
-                            {
-                                log::error!("error applying worktree update: {}", error);
-                            }
-                            lock.1.push(update);
                         }
-                        snapshot_updated_tx.send(()).await.ok();
+                        lock.1.push(update);
                     }
-                })
+                    snapshot_updated_tx.send(()).await.ok();
-                .detach();
+                }
+            })
+            .detach();
             // On the foreground task, update to the latest snapshot and notify
             // any update observer of all updates that led to that snapshot.
             Worktree::Local(this) => {
                 let path = Arc::from(path);
                 let snapshot = this.snapshot();
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     if let Some(repo) = snapshot.repository_for_path(&path) {
                         if let Some(repo_path) = repo.relativize(&path).log_err() {
                             if let Some(git_repo) =
             Worktree::Local(this) => {
                 let path = Arc::from(path);
                 let snapshot = this.snapshot();
-                cx.background_executor().spawn(async move {
+                cx.background_spawn(async move {
                     if let Some(repo) = snapshot.repository_for_path(&path) {
                         if let Some(repo_path) = repo.relativize(&path).log_err() {
                             if let Some(git_repo) =
         let git_hosting_provider_registry = GitHostingProviderRegistry::try_global(cx);
         let settings = self.settings.clone();
         let (scan_states_tx, mut scan_states_rx) = mpsc::unbounded();
-        let background_scanner = cx.background_executor().spawn({
+        let background_scanner = cx.background_spawn({
             let abs_path = snapshot.abs_path.as_path().to_path_buf();
             let background = cx.background_executor().clone();
             async move {
         let is_private = self.is_path_private(path.as_ref());
         let worktree = cx.weak_entity();
-        cx.background_executor().spawn(async move {
+        cx.background_spawn(async move {
             let abs_path = abs_path?;
             let content = fs.load_bytes(&abs_path).await?;
         let path_excluded = self.settings.is_path_excluded(&abs_path);
         let fs = self.fs.clone();
         let task_abs_path = abs_path.clone();
-        let write = cx.background_executor().spawn(async move {
+        let write = cx.background_spawn(async move {
             if is_dir {
                 fs.create_dir(&task_abs_path)
                     .await
             return Task::ready(Err(anyhow!("invalid path {path:?}")));
         };
-        let write = cx.background_executor().spawn({
+        let write = cx.background_spawn({
             let fs = fs.clone();
             let abs_path = abs_path.clone();
             async move { fs.save(&abs_path, &text, line_ending).await }
         let abs_path = self.absolutize(&entry.path);
         let fs = self.fs.clone();
-        let delete = cx.background_executor().spawn(async move {
+        let delete = cx.background_spawn(async move {
             if entry.is_file() {
                 if trash {
                     fs.trash_file(&abs_path?, Default::default()).await?;
         let abs_path = abs_new_path.clone();
         let fs = self.fs.clone();
         let case_sensitive = self.fs_case_sensitive;
-        let rename = cx.background_executor().spawn(async move {
+        let rename = cx.background_spawn(async move {
             let abs_old_path = abs_old_path?;
             let abs_new_path = abs_new_path;
             };
         let abs_new_path = self.absolutize(&new_path);
         let fs = self.fs.clone();
-        let copy = cx.background_executor().spawn(async move {
+        let copy = cx.background_spawn(async move {
             copy_recursive(
                 fs.as_ref(),
                 &abs_old_path?,
             .collect::<Vec<_>>();
         cx.spawn(|this, cx| async move {
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                for (source, target) in paths {
-                    for (source, target) in paths {
+                    copy_recursive(
-                        copy_recursive(
+                        fs.as_ref(),
-                            fs.as_ref(),
+                        &source,
-                            &source,
+                        &target,
-                            &target,
+                        fs::CopyOptions {
-                            fs::CopyOptions {
+                            overwrite: overwrite_existing_files,
-                                overwrite: overwrite_existing_files,
+                            ..Default::default()
-                                ..Default::default()
+                        },
-                            },
+                    )
-                        )
+                    .await
-                        .await
+                    .with_context(|| {
-                        .with_context(|| {
+                        anyhow!("Failed to copy file from {source:?} to {target:?}")
-                            anyhow!("Failed to copy file from {source:?} to {target:?}")
+                    })?;
-                        })?;
+                }
-                    }
+                Ok::<(), anyhow::Error>(())
-                    Ok::<(), anyhow::Error>(())
+            })
-                })
+            .await
-                .await
+            .log_err();
-                .log_err();
             let mut refresh = cx.read_entity(
                 &this.upgrade().with_context(|| "Dropped worktree")?,
                 |this, _| {
                 },
             )??;
-            cx.background_executor()
+            cx.background_spawn(async move {
-                .spawn(async move {
+                refresh.next().await;
-                    refresh.next().await;
+                Ok::<(), anyhow::Error>(())
-                    Ok::<(), anyhow::Error>(())
+            })
-                })
+            .await
-                .await
+            .log_err();
-                .log_err();
             let this = this.upgrade().with_context(|| "Dropped worktree")?;
             cx.read_entity(&this, |this, _| {
     ) -> Option<Task<Result<()>>> {
         let path = self.entry_for_id(entry_id)?.path.clone();
         let mut refresh = self.refresh_entries_for_paths(vec![path]);
-        Some(cx.background_executor().spawn(async move {
+        Some(cx.background_spawn(async move {
             refresh.next().await;
             Ok(())
         }))
     ) -> Option<Task<Result<()>>> {
         let path = self.entry_for_id(entry_id).unwrap().path.clone();
         let mut rx = self.add_path_prefix_to_scan(path.clone());
-        Some(cx.background_executor().spawn(async move {
+        Some(cx.background_spawn(async move {
             rx.next().await;
             Ok(())
         }))
             .ok();
         let worktree_id = cx.entity_id().as_u64();
-        let _maintain_remote_snapshot = cx.background_executor().spawn(async move {
+        let _maintain_remote_snapshot = cx.background_spawn(async move {
             let mut is_first = true;
             while let Some((snapshot, entry_changes, repo_changes)) = snapshots_rx.next().await {
                 let update = if is_first {
         let worktree = self.worktree.read(cx).as_local().unwrap();
         let abs_path = worktree.absolutize(&self.path);
         let fs = worktree.fs.clone();
-        cx.background_executor()
+        cx.background_spawn(async move { fs.load(&abs_path?).await })
-            .spawn(async move { fs.load(&abs_path?).await })
     }
     fn load_bytes(&self, cx: &App) -> Task<Result<Vec<u8>>> {
         let worktree = self.worktree.read(cx).as_local().unwrap();
         let abs_path = worktree.absolutize(&self.path);
         let fs = worktree.fs.clone();
-        cx.background_executor()
+        cx.background_spawn(async move { fs.load_bytes(&abs_path?).await })
-            .spawn(async move { fs.load_bytes(&abs_path?).await })
     }
 }

crates/worktree/src/worktree_tests.rs+4−4

@@ -11,7 +11,7 @@ use git::{ · 10 unmodified lines
11	},	11	},
12	GITIGNORE,	12	GITIGNORE,
13	};	13	};
14	use gpui::{BorrowAppContext, Context, Task, TestAppContext};	14	use gpui::{AppContext as _, BorrowAppContext, Context, Task, TestAppContext};
15	use parking_lot::Mutex;	15	use parking_lot::Mutex;
16	use postage::stream::Stream;	16	use postage::stream::Stream;
17	use pretty_assertions::assert_eq;	17	use pretty_assertions::assert_eq;
@@ -1954,7 +1954,7 @@ fn randomly_mutate_worktree( · 1936 unmodified lines
1954	new_path	1954	new_path
1955	);	1955	);
1956	let task = worktree.rename_entry(entry.id, new_path, cx);	1956	let task = worktree.rename_entry(entry.id, new_path, cx);
1957	cx.background_executor().spawn(async move {	1957	cx.background_spawn(async move {
1958	task.await?.to_included().unwrap();	1958	task.await?.to_included().unwrap();
1959	Ok(())	1959	Ok(())
1960	})	1960	})
@@ -1969,7 +1969,7 @@ fn randomly_mutate_worktree( · 8 unmodified lines
1969	child_path,	1969	child_path,
1970	);	1970	);
1971	let task = worktree.create_entry(child_path, is_dir, cx);	1971	let task = worktree.create_entry(child_path, is_dir, cx);
1972	cx.background_executor().spawn(async move {	1972	cx.background_spawn(async move {
1973	task.await?;	1973	task.await?;
1974	Ok(())	1974	Ok(())
1975	})	1975	})
@@ -1977,7 +1977,7 @@ fn randomly_mutate_worktree( · 1 unmodified line
1977	log::info!("overwriting file {:?} ({})", entry.path, entry.id.0);	1977	log::info!("overwriting file {:?} ({})", entry.path, entry.id.0);
1978	let task =	1978	let task =
1979	worktree.write_file(entry.path.clone(), "".into(), Default::default(), cx);	1979	worktree.write_file(entry.path.clone(), "".into(), Default::default(), cx);
1980	cx.background_executor().spawn(async move {	1980	cx.background_spawn(async move {
1981	task.await?;	1981	task.await?;
1982	Ok(())	1982	Ok(())
1983	})	1983	})

crates/zed/src/reliability.rs+36−38

@@ -4,7 +4,7 @@ use backtrace::{self, Backtrace}; · 3 unmodified lines
4	use chrono::Utc;	4	use chrono::Utc;
5	use client::{telemetry, TelemetrySettings};	5	use client::{telemetry, TelemetrySettings};
6	use db::kvp::KEY_VALUE_STORE;	6	use db::kvp::KEY_VALUE_STORE;
7	use gpui::{App, SemanticVersion};	7	use gpui::{App, AppContext as _, SemanticVersion};
8	use http_client::{self, HttpClient, HttpClientWithUrl, HttpRequestExt, Method};	8	use http_client::{self, HttpClient, HttpClientWithUrl, HttpRequestExt, Method};
9	use paths::{crashes_dir, crashes_retired_dir};	9	use paths::{crashes_dir, crashes_retired_dir};
10	use project::Project;	10	use project::Project;
@@ -205,35 +205,34 @@ pub fn init( · 194 unmodified lines
205	ssh_client.update(cx, \|client, cx\| {	205	ssh_client.update(cx, \|client, cx\| {
206	if TelemetrySettings::get_global(cx).diagnostics {	206	if TelemetrySettings::get_global(cx).diagnostics {
207	let request = client.proto_client().request(proto::GetPanicFiles {});	207	let request = client.proto_client().request(proto::GetPanicFiles {});
208	cx.background_executor()	208	cx.background_spawn(async move {
209	.spawn(async move {	209	let panic_files = request.await?;
210	let panic_files = request.await?;	210	for file in panic_files.file_contents {
211	for file in panic_files.file_contents {	211	let panic: Option<Panic> = serde_json::from_str(&file)
212	let panic: Option<Panic> = serde_json::from_str(&file)	212	.log_err()
213	.log_err()	213	.or_else(\|\| {
214	.or_else(\|\| {	214	file.lines()
215	file.lines()	215	.next()
216	.next()	216	.and_then(\|line\| serde_json::from_str(line).ok())
217	.and_then(\|line\| serde_json::from_str(line).ok())	217	})
218	})	218	.unwrap_or_else(\|\| {
219	.unwrap_or_else(\|\| {	219	log::error!("failed to deserialize panic file {:?}", file);
220	log::error!("failed to deserialize panic file {:?}", file);	220	None
221	None	221	});
222	});	222
223		223	if let Some(mut panic) = panic {
224	if let Some(mut panic) = panic {	224	panic.session_id = session_id.clone();
225	panic.session_id = session_id.clone();	225	panic.system_id = system_id.clone();
226	panic.system_id = system_id.clone();	226	panic.installation_id = installation_id.clone();
227	panic.installation_id = installation_id.clone();	227
228		228	upload_panic(&http_client, &panic_report_url, panic, &mut None)
229	upload_panic(&http_client, &panic_report_url, panic, &mut None)	229	.await?;
230	.await?;
231	}
232	}	230	}
		231	}
233		232
234	anyhow::Ok(())	233	anyhow::Ok(())
235	})	234	})
236	.detach_and_log_err(cx);	235	.detach_and_log_err(cx);
237	}	236	}
238	})	237	})
239	}	238	}
@@ -450,18 +449,17 @@ fn upload_panics_and_crashes( · 210 unmodified lines
450	cx: &App,	449	cx: &App,
451	) {	450	) {
452	let telemetry_settings = *client::TelemetrySettings::get_global(cx);	451	let telemetry_settings = *client::TelemetrySettings::get_global(cx);
453	cx.background_executor()	452	cx.background_spawn(async move {
454	.spawn(async move {	453	let most_recent_panic =
455	let most_recent_panic =	454	upload_previous_panics(http.clone(), &panic_report_url, telemetry_settings)
456	upload_previous_panics(http.clone(), &panic_report_url, telemetry_settings)
457	.await
458	.log_err()
459	.flatten();
460	upload_previous_crashes(http, most_recent_panic, installation_id, telemetry_settings)
461	.await	455	.await
462	.log_err()	456	.log_err()
463	})	457	.flatten();
464	.detach()	458	upload_previous_crashes(http, most_recent_panic, installation_id, telemetry_settings)
		459	.await
		460	.log_err()
		461	})
		462	.detach()
465	}	463	}
466		464
467	/// Uploads panics via `zed.dev`.	465	/// Uploads panics via `zed.dev`.

crates/zed/src/zed.rs+2−2

@@ -956,7 +956,7 @@ fn install_cli( · 955 unmodified lines
956	Some(LINUX_PROMPT_DETAIL),	956	Some(LINUX_PROMPT_DETAIL),
957	&["Ok"],	957	&["Ok"],
958	);	958	);
959	cx.background_executor().spawn(prompt).detach();	959	cx.background_spawn(prompt).detach();
960	return Ok(());	960	return Ok(());
961	}	961	}
962	let path = install_cli::install_cli(cx.deref())	962	let path = install_cli::install_cli(cx.deref())
@@ -1335,7 +1335,7 @@ fn show_markdown_app_notification<F>( · 372 unmodified lines
1335	) where	1335	) where
1336	F: 'static + Send + Sync + Fn(&mut Window, &mut Context<MessageNotification>),	1336	F: 'static + Send + Sync + Fn(&mut Window, &mut Context<MessageNotification>),
1337	{	1337	{
1338	let parsed_markdown = cx.background_executor().spawn(async move {	1338	let parsed_markdown = cx.background_spawn(async move {
1339	let file_location_directory = None;	1339	let file_location_directory = None;
1340	let language_registry = None;	1340	let language_registry = None;
1341	markdown_preview::markdown_parser::parse_markdown(	1341	markdown_preview::markdown_parser::parse_markdown(

crates/zed/src/zed/inline_completion_registry.rs+1−1

@@ -3,7 +3,7 @@ use collections::HashMap; · 2 unmodified lines
3	use copilot::{Copilot, CopilotCompletionProvider};	3	use copilot::{Copilot, CopilotCompletionProvider};
4	use editor::{Editor, EditorMode};	4	use editor::{Editor, EditorMode};
5	use feature_flags::{FeatureFlagAppExt, PredictEditsFeatureFlag};	5	use feature_flags::{FeatureFlagAppExt, PredictEditsFeatureFlag};
6	use gpui::{AnyWindowHandle, App, AppContext, Context, Entity, WeakEntity};	6	use gpui::{AnyWindowHandle, App, AppContext as _, Context, Entity, WeakEntity};
7	use language::language_settings::{all_language_settings, EditPredictionProvider};	7	use language::language_settings::{all_language_settings, EditPredictionProvider};
8	use settings::SettingsStore;	8	use settings::SettingsStore;
9	use std::{cell::RefCell, rc::Rc, sync::Arc};	9	use std::{cell::RefCell, rc::Rc, sync::Arc};

crates/zeta/src/zeta.rs+3−5

             }
             let values = cx
-                .background_executor()
+                .background_spawn({
-                .spawn({
                     let snapshot = snapshot.clone();
                     let path = path.clone();
                     async move {
             let output_excerpt: Arc<str> = output_excerpt.into();
             let edits: Arc<[(Range<Anchor>, String)]> = cx
-                .background_executor()
+                .background_spawn({
-                .spawn({
                     let output_excerpt = output_excerpt.clone();
                     let editable_range = editable_range.clone();
                     let snapshot = snapshot.clone();
                 .map(|file| worktree.load_file(file, cx))
                 .collect::<ArrayVec<_, { LICENSE_FILES_TO_CHECK.len() }>>();
-            cx.background_executor().spawn(async move {
+            cx.background_spawn(async move {
                 for loaded_file in loaded_files.into_iter() {
                     let Ok(loaded_file) = loaded_file.await else {
                         continue;

@@ -171,7 +171,7 @@ impl WrapMap { · 170 unmodified lines
171		171
172	let text_system = cx.text_system().clone();	172	let text_system = cx.text_system().clone();
173	let (font, font_size) = self.font_with_size.clone();	173	let (font, font_size) = self.font_with_size.clone();
174	let task = cx.background_executor().spawn(async move {	174	let task = cx.background_spawn(async move {
175	let mut line_wrapper = text_system.line_wrapper(font, font_size);	175	let mut line_wrapper = text_system.line_wrapper(font, font_size);
176	let tab_snapshot = new_snapshot.tab_snapshot.clone();	176	let tab_snapshot = new_snapshot.tab_snapshot.clone();
177	let range = TabPoint::zero()..tab_snapshot.max_point();	177	let range = TabPoint::zero()..tab_snapshot.max_point();
@@ -255,7 +255,7 @@ impl WrapMap { · 77 unmodified lines
255	let mut snapshot = self.snapshot.clone();	255	let mut snapshot = self.snapshot.clone();
256	let text_system = cx.text_system().clone();	256	let text_system = cx.text_system().clone();
257	let (font, font_size) = self.font_with_size.clone();	257	let (font, font_size) = self.font_with_size.clone();
258	let update_task = cx.background_executor().spawn(async move {	258	let update_task = cx.background_spawn(async move {
259	let mut edits = Patch::default();	259	let mut edits = Patch::default();
260	let mut line_wrapper = text_system.line_wrapper(font, font_size);	260	let mut line_wrapper = text_system.line_wrapper(font, font_size);
261	for (tab_snapshot, tab_edits) in pending_edits {	261	for (tab_snapshot, tab_edits) in pending_edits {