buffer: Keep the shorter language setting names for the common operation (#43915)

cc
https://github.com/zed-industries/zed/pull/43888#issuecomment-3597265087

Release Notes:

- N/A *or* Added/Fixed/Improved ...

crates/acp_thread/src/diff.rs

@@ -35,9 +35,7 @@ impl Diff {
                     .await
                     .log_err();
 
-                buffer.update(cx, |buffer, cx| {
-                    buffer.set_language_immediate(language.clone(), cx)
-                })?;
+                buffer.update(cx, |buffer, cx| buffer.set_language(language.clone(), cx))?;
 
                 let diff = build_buffer_diff(
                     old_text.unwrap_or("".into()).into(),
@@ -263,7 +261,7 @@ impl PendingDiff {
                 self.new_buffer.read(cx).as_rope().clone(),
             );
             let mut buffer = Buffer::build(buffer, None, Capability::ReadWrite);
-            buffer.set_language_immediate(language, cx);
+            buffer.set_language(language, cx);
             buffer
         });
 

crates/agent_ui/src/acp/message_editor.rs

@@ -118,8 +118,7 @@ impl MessageEditor {
         );
 
         let editor = cx.new(|cx| {
-            let buffer =
-                cx.new(|cx| Buffer::local("", cx).with_language_immediate(Arc::new(language), cx));
+            let buffer = cx.new(|cx| Buffer::local("", cx).with_language(Arc::new(language), cx));
             let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
 
             let mut editor = Editor::new(mode, buffer, None, window, cx);

crates/agent_ui/src/acp/thread_view.rs

@@ -4839,7 +4839,7 @@ impl AcpThreadView {
 
             buffer.update(cx, |buffer, cx| {
                 buffer.set_text(markdown, cx);
-                buffer.set_language_immediate(Some(markdown_language), cx);
+                buffer.set_language(Some(markdown_language), cx);
                 buffer.set_capability(language::Capability::ReadWrite, cx);
             })?;
 

crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs

@@ -94,9 +94,7 @@ impl ConfigurationSource {
                 editor.set_show_gutter(false, cx);
                 editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx);
                 if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
-                    buffer.update(cx, |buffer, cx| {
-                        buffer.set_language_immediate(jsonc_language, cx)
-                    })
+                    buffer.update(cx, |buffer, cx| buffer.set_language(jsonc_language, cx))
                 }
                 editor
             })

crates/agent_ui/src/buffer_codegen.rs

@@ -269,7 +269,7 @@ impl CodegenAlternative {
                 .language_registry();
 
             let mut buffer = Buffer::local_normalized(text, line_ending, cx);
-            buffer.set_language_immediate(language, cx);
+            buffer.set_language(language, cx);
             if let Some(language_registry) = language_registry {
                 buffer.set_language_registry(language_registry);
             }
@@ -1077,8 +1077,7 @@ mod tests {
                 }
             }
         "};
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
         let range = buffer.read_with(cx, |buffer, cx| {
             let snapshot = buffer.snapshot(cx);
@@ -1140,8 +1139,7 @@ mod tests {
                 le
             }
         "};
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
         let range = buffer.read_with(cx, |buffer, cx| {
             let snapshot = buffer.snapshot(cx);
@@ -1205,8 +1203,7 @@ mod tests {
             "  \n",
             "}\n" //
         );
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
         let range = buffer.read_with(cx, |buffer, cx| {
             let snapshot = buffer.snapshot(cx);
@@ -1322,8 +1319,7 @@ mod tests {
                 let x = 0;
             }
         "};
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
         let range = buffer.read_with(cx, |buffer, cx| {
             let snapshot = buffer.snapshot(cx);

crates/agent_ui/src/text_thread_editor.rs

@@ -3095,7 +3095,7 @@ mod tests {
             "#
             .unindent();
             let mut buffer = Buffer::local(text, cx);
-            buffer.set_language_immediate(Some(markdown.clone()), cx);
+            buffer.set_language(Some(markdown.clone()), cx);
             buffer
         });
         let snapshot = buffer.read(cx).snapshot();

crates/assistant_text_thread/src/text_thread.rs

@@ -1223,9 +1223,8 @@ impl TextThread {
         cx.spawn(async move |this, cx| {
             let markdown = markdown.await?;
             this.update(cx, |this, cx| {
-                this.buffer.update(cx, |buffer, cx| {
-                    buffer.set_language_immediate(Some(markdown), cx)
-                });
+                this.buffer
+                    .update(cx, |buffer, cx| buffer.set_language(Some(markdown), cx));
             })
         })
         .detach_and_log_err(cx);

crates/collab_ui/src/channel_view.rs

@@ -171,7 +171,7 @@ impl ChannelView {
                     let Some(markdown) = markdown else {
                         return;
                     };
-                    buffer.set_language_immediate(Some(markdown), cx);
+                    buffer.set_language(Some(markdown), cx);
                 })
             })?;
 

crates/debugger_tools/src/dap_log.rs

@@ -830,7 +830,7 @@ impl DapLogView {
                         async move |buffer, cx| {
                             let language = language.await.ok();
                             buffer.update(cx, |buffer, cx| {
-                                buffer.set_language_immediate(language, cx);
+                                buffer.set_language(language, cx);
                             })
                         }
                     })
@@ -901,7 +901,7 @@ impl DapLogView {
                         async move |_, cx| {
                             let language = language.await.ok();
                             buffer.update(cx, |buffer, cx| {
-                                buffer.set_language_immediate(language, cx);
+                                buffer.set_language(language, cx);
                             })
                         }
                     })

crates/debugger_ui/src/tests/inline_values.rs

@@ -224,7 +224,7 @@ fn main() {
         .unwrap();
 
     buffer.update(cx, |buffer, cx| {
-        buffer.set_language_immediate(Some(Arc::new(rust_lang())), cx);
+        buffer.set_language(Some(Arc::new(rust_lang())), cx);
     });
 
     let (editor, cx) = cx.add_window_view(|window, cx| {
@@ -1593,7 +1593,7 @@ def process_data(untyped_param, typed_param: int, another_typed: str):
         .unwrap();
 
     buffer.update(cx, |buffer, cx| {
-        buffer.set_language_immediate(Some(Arc::new(python_lang())), cx);
+        buffer.set_language(Some(Arc::new(python_lang())), cx);
     });
 
     let (editor, cx) = cx.add_window_view(|window, cx| {
@@ -2091,7 +2091,7 @@ async fn test_inline_values_util(
         .unwrap();
 
     buffer.update(cx, |buffer, cx| {
-        buffer.set_language_immediate(Some(Arc::new(language)), cx);
+        buffer.set_language(Some(Arc::new(language)), cx);
     });
 
     let (editor, cx) = cx.add_window_view(|window, cx| {

crates/edit_prediction_context/src/excerpt.rs

@@ -475,8 +475,7 @@ mod tests {
     use util::test::{generate_marked_text, marked_text_offsets_by};
 
     fn create_buffer(text: &str, cx: &mut TestAppContext) -> BufferSnapshot {
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(rust_lang().into(), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(rust_lang().into(), cx));
         buffer.read_with(cx, |buffer, _| buffer.snapshot())
     }
 

crates/edit_prediction_context/src/imports.rs

@@ -1100,7 +1100,7 @@ mod test {
     ) {
         let buffer = cx.new(|cx| {
             let mut buffer = Buffer::local(source, cx);
-            buffer.set_language_immediate(Some(language.clone()), cx);
+            buffer.set_language(Some(language.clone()), cx);
             buffer
         });
         cx.run_until_parked();

crates/edit_prediction_context/src/reference.rs

@@ -148,9 +148,8 @@ mod test {
     }
 
     fn create_buffer(text: &str, cx: &mut TestAppContext) -> BufferSnapshot {
-        let buffer = cx.new(|cx| {
-            language::Buffer::local(text, cx).with_language_immediate(rust_lang().into(), cx)
-        });
+        let buffer =
+            cx.new(|cx| language::Buffer::local(text, cx).with_language(rust_lang().into(), cx));
         buffer.read_with(cx, |buffer, _| buffer.snapshot())
     }
 

crates/edit_prediction_context/src/syntax_index.rs

@@ -531,7 +531,7 @@ impl SyntaxIndex {
 
                 let buffer = cx.new(|cx| {
                     let mut buffer = Buffer::local(loaded_file.text, cx);
-                    buffer.set_language_immediate(Some(language.clone()), cx);
+                    buffer.set_language(Some(language.clone()), cx);
                     buffer
                 })?;
 

crates/editor/src/display_map.rs

@@ -2210,7 +2210,7 @@ pub mod tests {
             })
         });
 
-        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
         cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
 
@@ -2312,7 +2312,7 @@ pub mod tests {
 
         cx.update(|cx| init_test(cx, |_| {}));
 
-        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
         cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
         let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
@@ -2647,7 +2647,7 @@ pub mod tests {
 
         cx.update(|cx| init_test(cx, |_| {}));
 
-        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
         cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
 
@@ -2734,7 +2734,7 @@ pub mod tests {
 
         let (text, highlighted_ranges) = marked_text_ranges(r#"constˇ «a»«:» B = "c «d»""#, false);
 
-        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
         cx.condition(&buffer, |buf, _| !buf.is_parsing()).await;
 
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));

crates/editor/src/editor_tests.rs

@@ -2878,7 +2878,7 @@ async fn test_delete_to_bracket(cx: &mut TestAppContext) {
     );
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     cx.set_state(r#"macro!("// ˇCOMMENT");"#);
     cx.update_editor(|editor, window, cx| {
@@ -3109,7 +3109,7 @@ async fn test_newline_yaml(cx: &mut TestAppContext) {
 
     let mut cx = EditorTestContext::new(cx).await;
     let yaml_language = languages::language("yaml", tree_sitter_yaml::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(yaml_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(yaml_language), cx));
 
     // Object (between 2 fields)
     cx.set_state(indoc! {"
@@ -3272,7 +3272,7 @@ async fn test_newline_above(cx: &mut TestAppContext) {
     );
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
     cx.set_state(indoc! {"
         const a: ˇA = (
             (ˇ
@@ -3320,7 +3320,7 @@ async fn test_newline_below(cx: &mut TestAppContext) {
     );
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
     cx.set_state(indoc! {"
         const a: ˇA = (
             (ˇ
@@ -3367,7 +3367,7 @@ async fn test_newline_comments(cx: &mut TestAppContext) {
     ));
     {
         let mut cx = EditorTestContext::new(cx).await;
-        cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
         cx.set_state(indoc! {"
         // Fooˇ
     "});
@@ -3439,7 +3439,7 @@ async fn test_newline_comments_with_multiple_delimiters(cx: &mut TestAppContext)
     ));
     {
         let mut cx = EditorTestContext::new(cx).await;
-        cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
         cx.set_state(indoc! {"
         //ˇ
     "});
@@ -3486,7 +3486,7 @@ async fn test_newline_documentation_comments(cx: &mut TestAppContext) {
 
     {
         let mut cx = EditorTestContext::new(cx).await;
-        cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
         cx.set_state(indoc! {"
         /**ˇ
     "});
@@ -3695,7 +3695,7 @@ async fn test_newline_comments_with_block_comment(cx: &mut TestAppContext) {
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(lua_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(lua_language), cx));
 
     // Line with line comment should extend
     cx.set_state(indoc! {"
@@ -3816,7 +3816,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_lines(cx: &mut TestAppConte
         .with_indents_query(r#"(_ "(" ")" @end) @indent"#)
         .unwrap(),
     );
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test when all cursors are not at suggested indent
     // then simply move to their suggested indent location
@@ -4040,7 +4040,7 @@ async fn test_tab_with_mixed_whitespace_rust(cx: &mut TestAppContext) {
     );
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
     cx.set_state(indoc! {"
         fn a() {
             if b {
@@ -4139,7 +4139,7 @@ async fn test_indent_yaml_comments_with_multiple_cursors(cx: &mut TestAppContext
 
     let mut cx = EditorTestContext::new(cx).await;
     let yaml_language = languages::language("yaml", tree_sitter_yaml::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(yaml_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(yaml_language), cx));
 
     cx.set_state(
         r#"ˇ#     ingress:
@@ -4174,7 +4174,7 @@ async fn test_indent_yaml_non_comments_with_multiple_cursors(cx: &mut TestAppCon
 
     let mut cx = EditorTestContext::new(cx).await;
     let yaml_language = languages::language("yaml", tree_sitter_yaml::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(yaml_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(yaml_language), cx));
 
     cx.set_state(
         r#"ˇingress:
@@ -4329,10 +4329,9 @@ fn test_indent_outdent_with_excerpts(cx: &mut TestAppContext) {
     ));
 
     let toml_buffer =
-        cx.new(|cx| Buffer::local("a = 1\nb = 2\n", cx).with_language_immediate(toml_language, cx));
-    let rust_buffer = cx.new(|cx| {
-        Buffer::local("const c: usize = 3;\n", cx).with_language_immediate(rust_language, cx)
-    });
+        cx.new(|cx| Buffer::local("a = 1\nb = 2\n", cx).with_language(toml_language, cx));
+    let rust_buffer =
+        cx.new(|cx| Buffer::local("const c: usize = 3;\n", cx).with_language(rust_language, cx));
     let multibuffer = cx.new(|cx| {
         let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
@@ -5031,7 +5030,7 @@ async fn test_wrap_in_tag_single_selection(cx: &mut TestAppContext) {
         None,
     ));
 
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(js_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(js_language), cx));
 
     cx.set_state(indoc! {"
         «testˇ»
@@ -5080,7 +5079,7 @@ async fn test_wrap_in_tag_multi_selection(cx: &mut TestAppContext) {
         None,
     ));
 
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(js_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(js_language), cx));
 
     cx.set_state(indoc! {"
         «testˇ»
@@ -5123,7 +5122,7 @@ async fn test_wrap_in_tag_does_nothing_in_unsupported_languages(cx: &mut TestApp
         None,
     ));
 
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(plaintext_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(plaintext_language), cx));
 
     cx.set_state(indoc! {"
         «testˇ»
@@ -6569,7 +6568,7 @@ async fn test_rewrap(cx: &mut TestAppContext) {
         language: Arc<Language>,
         cx: &mut EditorTestContext,
     ) {
-        cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
         cx.set_state(unwrapped_text);
         cx.update_editor(|e, window, cx| e.rewrap(&Rewrap, window, cx));
         cx.assert_editor_state(wrapped_text);
@@ -6974,7 +6973,7 @@ async fn test_rewrap_block_comments(cx: &mut TestAppContext) {
         language: Arc<Language>,
         cx: &mut EditorTestContext,
     ) {
-        cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
         cx.set_state(unwrapped_text);
         cx.update_editor(|e, window, cx| e.rewrap(&Rewrap, window, cx));
         cx.assert_editor_state(wrapped_text);
@@ -6986,7 +6985,7 @@ async fn test_hard_wrap(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
     let mut cx = EditorTestContext::new(cx).await;
 
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(git_commit_lang()), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(git_commit_lang()), cx));
     cx.update_editor(|editor, _, cx| {
         editor.set_hard_wrap(Some(14), cx);
     });
@@ -7425,7 +7424,7 @@ async fn test_paste_multiline(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(rust_lang()), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(rust_lang()), cx));
 
     // Cut an indented block, without the leading whitespace.
     cx.set_state(indoc! {"
@@ -7567,7 +7566,7 @@ async fn test_paste_content_from_other_app(cx: &mut TestAppContext) {
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(rust_lang()), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(rust_lang()), cx));
 
     cx.set_state(indoc! {"
         fn a() {
@@ -8971,7 +8970,7 @@ async fn test_select_larger_smaller_syntax_node(cx: &mut TestAppContext) {
     "#
     .unindent();
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
 
@@ -9156,7 +9155,7 @@ async fn test_select_larger_syntax_node_for_cursor_at_end(cx: &mut TestAppContex
 
     let text = "let a = 2;";
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
 
@@ -9226,7 +9225,7 @@ async fn test_select_larger_syntax_node_for_cursor_at_symbol(cx: &mut TestAppCon
     "#
     .unindent();
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
 
@@ -9403,7 +9402,7 @@ async fn test_select_larger_smaller_syntax_node_for_string(cx: &mut TestAppConte
     "#
     .unindent();
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
 
@@ -9577,7 +9576,7 @@ async fn test_unwrap_syntax_nodes(cx: &mut gpui::TestAppContext) {
     ));
 
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(indoc! { r#"use mod1::{mod2::{«mod3ˇ», mod4}, mod5::{mod6, «mod7ˇ»}};"# });
@@ -9790,7 +9789,7 @@ async fn test_autoindent(cx: &mut TestAppContext) {
 
     let text = "fn a() {}";
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -9859,7 +9858,7 @@ async fn test_autoindent_disabled(cx: &mut TestAppContext) {
 
     let text = "fn a() {}";
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -9998,7 +9997,7 @@ async fn test_autoindent_disabled_with_nested_language(cx: &mut TestAppContext)
     cx.language_registry().add(language.clone());
 
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(r#"struct A {ˇ}"#);
@@ -10085,9 +10084,7 @@ async fn test_autoindent_selections(cx: &mut TestAppContext) {
             let buffer = editor.buffer().update(cx, |buffer, _| {
                 buffer.all_buffers().iter().next().unwrap().clone()
             });
-            buffer.update(cx, |buffer, cx| {
-                buffer.set_language_immediate(Some(rust_lang()), cx)
-            });
+            buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
             buffer
         });
 
@@ -10180,7 +10177,7 @@ async fn test_autoclose_and_auto_surround_pairs(cx: &mut TestAppContext) {
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(
@@ -10369,7 +10366,7 @@ async fn test_always_treat_brackets_as_autoclosed_skip_over(cx: &mut TestAppCont
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(
@@ -10512,7 +10509,7 @@ async fn test_autoclose_with_embedded_language(cx: &mut TestAppContext) {
     cx.executor().run_until_parked();
 
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(html_language), cx);
+        buffer.set_language(Some(html_language), cx);
     });
 
     cx.set_state(
@@ -10690,7 +10687,7 @@ async fn test_autoclose_with_overrides(cx: &mut TestAppContext) {
 
     cx.language_registry().add(rust_language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(rust_language), cx);
+        buffer.set_language(Some(rust_language), cx);
     });
 
     cx.set_state(
@@ -10797,7 +10794,7 @@ async fn test_surround_with_pair(cx: &mut TestAppContext) {
     "#
     .unindent();
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -10947,7 +10944,7 @@ async fn test_delete_autoclose_pair(cx: &mut TestAppContext) {
     "#
     .unindent();
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -11075,7 +11072,7 @@ async fn test_always_treat_brackets_as_autoclosed_delete(cx: &mut TestAppContext
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(
@@ -11143,7 +11140,7 @@ async fn test_auto_replace_emoji_shortcode(cx: &mut TestAppContext) {
         Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
-    let buffer = cx.new(|cx| Buffer::local("", cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local("", cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -13180,7 +13177,7 @@ async fn test_handle_input_for_show_signature_help_auto_signature_help_true(
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     cx.set_state(
@@ -13321,7 +13318,7 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut TestA
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     // Ensure that signature_help is not called when no signature help is enabled.
@@ -15903,7 +15900,7 @@ async fn test_toggle_comment(cx: &mut TestAppContext) {
         },
         Some(tree_sitter_rust::LANGUAGE.into()),
     ));
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // If multiple selections intersect a line, the line is only toggled once.
     cx.set_state(indoc! {"
@@ -16024,7 +16021,7 @@ async fn test_toggle_comment_ignore_indent(cx: &mut TestAppContext) {
         },
         Some(tree_sitter_rust::LANGUAGE.into()),
     ));
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     let toggle_comments = &ToggleComments {
         advance_downwards: false,
@@ -16154,7 +16151,7 @@ async fn test_advance_downward_on_toggle_comment(cx: &mut TestAppContext) {
 
     cx.language_registry().add(language.clone());
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(language), cx);
+        buffer.set_language(Some(language), cx);
     });
 
     let toggle_comments = &ToggleComments {
@@ -16312,7 +16309,7 @@ async fn test_toggle_block_comment(cx: &mut TestAppContext) {
     cx.language_registry().add(html_language.clone());
     cx.language_registry().add(javascript_language);
     cx.update_buffer(|buffer, cx| {
-        buffer.set_language_immediate(Some(html_language), cx);
+        buffer.set_language(Some(html_language), cx);
     });
 
     // Toggle comments for empty selections
@@ -16747,7 +16744,7 @@ async fn test_extra_newline_insertion(cx: &mut TestAppContext) {
         "{{} }\n",     //
     );
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
     editor
@@ -17642,7 +17639,7 @@ async fn test_move_to_enclosing_bracket_in_markdown_code_block(cx: &mut TestAppC
             cx,
         );
         buffer.set_language_registry(language_registry.clone());
-        buffer.set_language_immediate(Some(markdown_lang()), cx);
+        buffer.set_language(Some(markdown_lang()), cx);
         buffer
     });
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
@@ -22454,7 +22451,7 @@ async fn test_find_enclosing_node_with_task(cx: &mut TestAppContext) {
     let project = Project::test(fs, ["/a".as_ref()], cx).await;
     let workspace = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
     let cx = &mut VisualTestContext::from_window(*workspace.deref(), cx);
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let multi_buffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
 
     let editor = cx.new_window_entity(|window, cx| {
@@ -23943,7 +23940,7 @@ async fn test_tree_sitter_brackets_newline_insertion(cx: &mut TestAppContext) {
         )
         .unwrap(),
     );
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     cx.set_state(indoc! {"
         <span>ˇ</span>
@@ -24828,7 +24825,7 @@ async fn test_linked_edits_on_typing_punctuation(cx: &mut TestAppContext) {
         },
         Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
     ));
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // Test typing > does not extend linked pair
     cx.set_state("<divˇ<div></div>");
@@ -25028,7 +25025,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_python(cx: &mut TestApp
 
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("python", tree_sitter_python::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test cursor move to start of each line on tab
     // for `if`, `elif`, `else`, `while`, `with` and `for`
@@ -25138,7 +25135,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) {
 
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("python", tree_sitter_python::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test `else` auto outdents when typed inside `if` block
     cx.set_state(indoc! {"
@@ -25370,7 +25367,7 @@ async fn test_indent_on_newline_for_python(cx: &mut TestAppContext) {
     });
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("python", tree_sitter_python::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test correct indent after newline on comment
     cx.set_state(indoc! {"
@@ -25431,7 +25428,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_bash(cx: &mut TestAppCo
 
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("bash", tree_sitter_bash::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test cursor move to start of each line on tab
     // for `if`, `elif`, `else`, `while`, `for`, `case` and `function`
@@ -25525,7 +25522,7 @@ async fn test_indent_after_input_for_bash(cx: &mut TestAppContext) {
 
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("bash", tree_sitter_bash::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test indents on comment insert
     cx.set_state(indoc! {"
@@ -25567,7 +25564,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) {
 
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("bash", tree_sitter_bash::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test `else` auto outdents when typed inside `if` block
     cx.set_state(indoc! {"
@@ -25720,7 +25717,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) {
     });
     let mut cx = EditorTestContext::new(cx).await;
     let language = languages::language("bash", tree_sitter_bash::LANGUAGE.into());
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // test correct indent after newline on comment
     cx.set_state(indoc! {"
@@ -27019,7 +27016,7 @@ async fn test_select_next_prev_syntax_node(cx: &mut TestAppContext) {
         }
     "#;
 
-    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language_immediate(language, cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));
     let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
     let (editor, cx) = cx.add_window_view(|window, cx| build_editor(buffer, window, cx));
 
@@ -27211,7 +27208,7 @@ async fn test_paste_url_from_other_app_creates_markdown_link_over_selected_text(
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(markdown_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
     cx.set_state("Hello, «editorˇ».\nZed is «ˇgreat» (see this link: ˇ)");
 
     cx.update_editor(|editor, window, cx| {
@@ -27241,7 +27238,7 @@ async fn test_paste_url_from_zed_copy_creates_markdown_link_over_selected_text(
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(markdown_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
     cx.set_state(&format!(
         "Hello, editor.\nZed is great (see this link: )\n«{url}ˇ»"
     ));
@@ -27280,7 +27277,7 @@ async fn test_paste_url_from_other_app_replaces_existing_url_without_creating_ma
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(markdown_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
     cx.set_state("Please visit zed's homepage: «https://www.apple.comˇ»");
 
     cx.update_editor(|editor, window, cx| {
@@ -27308,7 +27305,7 @@ async fn test_paste_plain_text_from_other_app_replaces_selection_without_creatin
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(markdown_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
     cx.set_state("Hello, «editorˇ».\nZed is «ˇgreat»");
 
     cx.update_editor(|editor, window, cx| {
@@ -27336,7 +27333,7 @@ async fn test_paste_url_from_other_app_without_creating_markdown_link_in_non_mar
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(markdown_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
     cx.set_state("// Hello, «editorˇ».\n// Zed is «ˇgreat» (see this link: ˇ)");
 
     cx.update_editor(|editor, window, cx| {
@@ -27388,7 +27385,7 @@ async fn test_paste_url_from_other_app_creates_markdown_link_selectively_in_mult
             .unwrap();
         let first_buffer = multi_buffer.read(cx).buffer(first_buffer_id).unwrap();
         first_buffer.update(cx, |buffer, cx| {
-            buffer.set_language_immediate(Some(markdown_language.clone()), cx);
+            buffer.set_language(Some(markdown_language.clone()), cx);
         });
 
         editor
@@ -27691,7 +27688,7 @@ async fn test_sticky_scroll(cx: &mut TestAppContext) {
             .as_singleton()
             .unwrap()
             .update(cx, |buffer, cx| {
-                buffer.set_language_immediate(Some(rust_lang()), cx);
+                buffer.set_language(Some(rust_lang()), cx);
             })
     });
 
@@ -27781,7 +27778,7 @@ async fn test_scroll_by_clicking_sticky_header(cx: &mut TestAppContext) {
             .as_singleton()
             .unwrap()
             .update(cx, |buffer, cx| {
-                buffer.set_language_immediate(Some(rust_lang()), cx);
+                buffer.set_language(Some(rust_lang()), cx);
             })
     });
 

crates/editor/src/items.rs

@@ -1139,7 +1139,7 @@ impl SerializableItem for Editor {
                     buffer.update(cx, |buffer, cx| {
                         buffer.set_language_registry(language_registry);
                         if let Some(language) = language {
-                            buffer.set_language_immediate(Some(language), cx);
+                            buffer.set_language(Some(language), cx);
                         }
                         buffer.set_text(contents, cx);
                         if let Some(entry) = buffer.peek_undo_stack() {

crates/editor/src/jsx_tag_auto_close.rs

@@ -638,7 +638,7 @@ mod jsx_tag_autoclose_tests {
         cx.update_buffer(|buffer, cx| {
             let language = language("tsx", tree_sitter_typescript::LANGUAGE_TSX.into());
 
-            buffer.set_language_immediate(Some(language), cx)
+            buffer.set_language(Some(language), cx)
         });
 
         cx
@@ -802,7 +802,7 @@ mod jsx_tag_autoclose_tests {
 
         let buffer_a = cx.new(|cx| {
             let mut buf = language::Buffer::local("<div", cx);
-            buf.set_language_immediate(
+            buf.set_language(
                 Some(language("tsx", tree_sitter_typescript::LANGUAGE_TSX.into())),
                 cx,
             );
@@ -810,7 +810,7 @@ mod jsx_tag_autoclose_tests {
         });
         let buffer_b = cx.new(|cx| {
             let mut buf = language::Buffer::local("<pre", cx);
-            buf.set_language_immediate(
+            buf.set_language(
                 Some(language("tsx", tree_sitter_typescript::LANGUAGE_TSX.into())),
                 cx,
             );

crates/editor/src/rust_analyzer_ext.rs

@@ -205,7 +205,7 @@ pub fn expand_macro_recursively(
         workspace.update_in(cx, |workspace, window, cx| {
             buffer.update(cx, |buffer, cx| {
                 buffer.set_text(macro_expansion.expansion, cx);
-                buffer.set_language_immediate(Some(rust_language), cx);
+                buffer.set_language(Some(rust_language), cx);
                 buffer.set_capability(Capability::ReadOnly, cx);
             });
             let multibuffer =

crates/editor/src/test/editor_test_context.rs

@@ -67,7 +67,7 @@ impl EditorTestContext {
             .await
             .unwrap();
         buffer.update(cx, |buffer, cx| {
-            buffer.set_language_immediate(Some(language), cx);
+            buffer.set_language(Some(language), cx);
         });
 
         let editor = cx.add_window(|window, cx| {

crates/git_ui/src/commit_view.rs

@@ -780,7 +780,7 @@ async fn build_buffer(
             text,
         );
         let mut buffer = Buffer::build(buffer, Some(blob), Capability::ReadWrite);
-        buffer.set_language(language, cx);
+        buffer.set_language_async(language, cx);
         buffer
     })?;
     Ok(buffer)

crates/git_ui/src/git_panel.rs

@@ -1628,7 +1628,7 @@ impl GitPanel {
         }
         let buffer = cx.new(|cx| {
             let mut buffer = Buffer::local(message, cx);
-            buffer.set_language_immediate(git_commit_language, cx);
+            buffer.set_language(git_commit_language, cx);
             buffer
         });
         let editor = cx.new(|cx| Editor::for_buffer(buffer, None, window, cx));

crates/git_ui/src/text_diff_view.rs

@@ -240,7 +240,7 @@ fn build_clipboard_buffer(
     cx.new(|cx| {
         let mut buffer = language::Buffer::local(source_buffer_snapshot.text(), cx);
         let language = source_buffer.read(cx).language().cloned();
-        buffer.set_language_immediate(language, cx);
+        buffer.set_language(language, cx);
 
         let range_start = source_buffer_snapshot.point_to_offset(replacement_range.start);
         let range_end = source_buffer_snapshot.point_to_offset(replacement_range.end);

crates/inspector_ui/src/div_inspector.rs

@@ -87,7 +87,7 @@ impl DivInspector {
                 // Rust Analyzer doesn't get started for it.
                 let rust_language_result = languages.language_for_name("Rust").await;
                 let rust_style_buffer = rust_language_result.and_then(|rust_language| {
-                    cx.new(|cx| Buffer::local("", cx).with_language(rust_language, cx))
+                    cx.new(|cx| Buffer::local("", cx).with_language_async(rust_language, cx))
                 });
 
                 match json_style_buffer.and_then(|json_style_buffer| {

crates/keymap_editor/src/keymap_editor.rs

@@ -2225,7 +2225,7 @@ impl KeybindingEditorModal {
                     .update(cx, |editor, cx| {
                         if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
                             buffer.update(cx, |buffer, cx| {
-                                buffer.set_language_immediate(Some(language), cx);
+                                buffer.set_language(Some(language), cx);
                             });
                         }
                         editor.set_completion_provider(Some(std::rc::Rc::new(
@@ -2815,7 +2815,7 @@ impl ActionArgumentsEditor {
                     this.editor.update(cx, |editor, cx| {
                         if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
                             buffer.update(cx, |buffer, cx| {
-                                buffer.set_language_immediate(Some(json_language.clone()), cx)
+                                buffer.set_language(Some(json_language.clone()), cx)
                             });
                         }
                     })

crates/language/src/buffer.rs

@@ -862,7 +862,7 @@ impl EditPreview {
                 self.applied_edits_snapshot.line_ending(),
                 cx,
             );
-            buffer.set_language(self.syntax_snapshot.root_language(), cx);
+            buffer.set_language_async(self.syntax_snapshot.root_language(), cx);
             buffer
         })
     }
@@ -1031,18 +1031,14 @@ impl Buffer {
     }
 
     /// Assign a language to the buffer, returning the buffer.
-    pub fn with_language(mut self, language: Arc<Language>, cx: &mut Context<Self>) -> Self {
-        self.set_language(Some(language), cx);
+    pub fn with_language_async(mut self, language: Arc<Language>, cx: &mut Context<Self>) -> Self {
+        self.set_language_async(Some(language), cx);
         self
     }
 
     /// Assign a language to the buffer, blocking for up to 1ms to reparse the buffer, returning the buffer.
-    pub fn with_language_immediate(
-        mut self,
-        language: Arc<Language>,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        self.set_language_immediate(Some(language), cx);
+    pub fn with_language(mut self, language: Arc<Language>, cx: &mut Context<Self>) -> Self {
+        self.set_language(Some(language), cx);
         self
     }
 
@@ -1372,16 +1368,12 @@ impl Buffer {
     }
 
     /// Assign a language to the buffer.
-    pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut Context<Self>) {
+    pub fn set_language_async(&mut self, language: Option<Arc<Language>>, cx: &mut Context<Self>) {
         self.set_language_(language, cfg!(any(test, feature = "test-support")), cx);
     }
 
     /// Assign a language to the buffer, blocking for up to 1ms to reparse the buffer.
-    pub fn set_language_immediate(
-        &mut self,
-        language: Option<Arc<Language>>,
-        cx: &mut Context<Self>,
-    ) {
+    pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut Context<Self>) {
         self.set_language_(language, true, cx);
     }
 

crates/language/src/buffer_tests.rs

@@ -46,8 +46,8 @@ fn test_line_endings(cx: &mut gpui::App) {
     init_settings(cx, |_| {});
 
     cx.new(|cx| {
-        let mut buffer = Buffer::local("one\r\ntwo\rthree", cx)
-            .with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer =
+            Buffer::local("one\r\ntwo\rthree", cx).with_language(Arc::new(rust_lang()), cx);
         assert_eq!(buffer.text(), "one\ntwo\nthree");
         assert_eq!(buffer.line_ending(), LineEnding::Windows);
 
@@ -608,8 +608,7 @@ async fn test_normalize_whitespace(cx: &mut gpui::TestAppContext) {
 #[gpui::test]
 async fn test_reparse(cx: &mut gpui::TestAppContext) {
     let text = "fn a() {}";
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
 
     // Wait for the initial text to parse
     cx.executor().run_until_parked();
@@ -736,7 +735,7 @@ async fn test_reparse(cx: &mut gpui::TestAppContext) {
 #[gpui::test]
 async fn test_resetting_language(cx: &mut gpui::TestAppContext) {
     let buffer = cx.new(|cx| {
-        let mut buffer = Buffer::local("{}", cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local("{}", cx).with_language(Arc::new(rust_lang()), cx);
         buffer.set_sync_parse_timeout(Duration::ZERO);
         buffer
     });
@@ -749,7 +748,7 @@ async fn test_resetting_language(cx: &mut gpui::TestAppContext) {
     );
 
     buffer.update(cx, |buffer, cx| {
-        buffer.set_language_immediate(Some(Arc::new(json_lang())), cx)
+        buffer.set_language(Some(Arc::new(json_lang())), cx)
     });
     cx.executor().run_until_parked();
     assert_eq!(get_tree_sexp(&buffer, cx), "(document (object))");
@@ -784,8 +783,7 @@ async fn test_outline(cx: &mut gpui::TestAppContext) {
     "#
     .unindent();
 
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
     let outline = buffer.update(cx, |buffer, _| buffer.snapshot().outline(None));
 
     assert_eq!(
@@ -867,8 +865,7 @@ async fn test_outline_nodes_with_newlines(cx: &mut gpui::TestAppContext) {
     "#
     .unindent();
 
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
     let outline = buffer.update(cx, |buffer, _| buffer.snapshot().outline(None));
 
     assert_eq!(
@@ -902,8 +899,7 @@ async fn test_outline_with_extra_context(cx: &mut gpui::TestAppContext) {
     "#
     .unindent();
 
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(language), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(language), cx));
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
 
     // extra context nodes are included in the outline.
@@ -949,8 +945,7 @@ fn test_outline_annotations(cx: &mut App) {
     "#
     .unindent();
 
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
     let outline = buffer.update(cx, |buffer, _| buffer.snapshot().outline(None));
 
     assert_eq!(
@@ -998,8 +993,7 @@ async fn test_symbols_containing(cx: &mut gpui::TestAppContext) {
     "#
     .unindent();
 
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
 
     // point is at the start of an item
@@ -1074,8 +1068,7 @@ async fn test_symbols_containing(cx: &mut gpui::TestAppContext) {
     "
         .unindent(),
     );
-    let buffer =
-        cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+    let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
 
     // note, it would be nice to actually return the method test in this
@@ -1094,9 +1087,8 @@ fn test_text_objects(cx: &mut App) {
         false,
     );
 
-    let buffer = cx.new(|cx| {
-        Buffer::local(text.clone(), cx).with_language_immediate(Arc::new(rust_lang()), cx)
-    });
+    let buffer =
+        cx.new(|cx| Buffer::local(text.clone(), cx).with_language(Arc::new(rust_lang()), cx));
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
 
     let matches = snapshot
@@ -1276,7 +1268,7 @@ fn test_enclosing_bracket_ranges_where_brackets_are_not_outermost_children(cx: &
 fn test_range_for_syntax_ancestor(cx: &mut App) {
     cx.new(|cx| {
         let text = "fn a() { b(|c| {}) }";
-        let buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
         let snapshot = buffer.snapshot();
 
         assert_eq!(
@@ -1328,7 +1320,7 @@ fn test_autoindent_with_soft_tabs(cx: &mut App) {
 
     cx.new(|cx| {
         let text = "fn a() {}";
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         buffer.edit([(8..8, "\n\n")], Some(AutoindentMode::EachLine), cx);
         assert_eq!(buffer.text(), "fn a() {\n    \n}");
@@ -1370,7 +1362,7 @@ fn test_autoindent_with_hard_tabs(cx: &mut App) {
 
     cx.new(|cx| {
         let text = "fn a() {}";
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         buffer.edit([(8..8, "\n\n")], Some(AutoindentMode::EachLine), cx);
         assert_eq!(buffer.text(), "fn a() {\n\t\n}");
@@ -1419,7 +1411,7 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut App)
             .unindent(),
             cx,
         )
-        .with_language_immediate(Arc::new(rust_lang()), cx);
+        .with_language(Arc::new(rust_lang()), cx);
 
         // Lines 2 and 3 don't match the indentation suggestion. When editing these lines,
         // their indentation is not adjusted.
@@ -1560,7 +1552,7 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut App)
             .unindent(),
             cx,
         )
-        .with_language_immediate(Arc::new(rust_lang()), cx);
+        .with_language(Arc::new(rust_lang()), cx);
 
         // Insert a closing brace. It is outdented.
         buffer.edit_via_marked_text(
@@ -1623,7 +1615,7 @@ fn test_autoindent_does_not_adjust_lines_within_newly_created_errors(cx: &mut Ap
             .unindent(),
             cx,
         )
-        .with_language_immediate(Arc::new(rust_lang()), cx);
+        .with_language(Arc::new(rust_lang()), cx);
 
         // Regression test: line does not get outdented due to syntax error
         buffer.edit_via_marked_text(
@@ -1682,7 +1674,7 @@ fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut App) {
             .unindent(),
             cx,
         )
-        .with_language_immediate(Arc::new(rust_lang()), cx);
+        .with_language(Arc::new(rust_lang()), cx);
 
         buffer.edit_via_marked_text(
             &"
@@ -1732,7 +1724,7 @@ fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut App) {
 
     cx.new(|cx| {
         let text = "a\nb";
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
         buffer.edit(
             [(0..1, "\n"), (2..3, "\n")],
             Some(AutoindentMode::EachLine),
@@ -1758,7 +1750,7 @@ fn test_autoindent_multi_line_insertion(cx: &mut App) {
         "
         .unindent();
 
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
         buffer.edit(
             [(Point::new(3, 0)..Point::new(3, 0), "e(\n    f()\n);\n")],
             Some(AutoindentMode::EachLine),
@@ -1795,7 +1787,7 @@ fn test_autoindent_block_mode(cx: &mut App) {
             }
         "#
         .unindent();
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         // When this text was copied, both of the quotation marks were at the same
         // indent level, but the indentation of the first line was not included in
@@ -1878,7 +1870,7 @@ fn test_autoindent_block_mode_with_newline(cx: &mut App) {
             }
         "#
         .unindent();
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         // First line contains just '\n', it's indentation is stored in "original_indent_columns"
         let original_indent_columns = vec![Some(4)];
@@ -1930,7 +1922,7 @@ fn test_autoindent_block_mode_without_original_indent_columns(cx: &mut App) {
             }
         "#
         .unindent();
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         // The original indent columns are not known, so this text is
         // auto-indented in a block as if the first line was copied in
@@ -2021,7 +2013,7 @@ fn test_autoindent_block_mode_multiple_adjacent_ranges(cx: &mut App) {
             false,
         );
 
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         buffer.edit(
             [
@@ -2072,7 +2064,7 @@ fn test_autoindent_language_without_indents_query(cx: &mut App) {
         "
         .unindent();
 
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(
+        let mut buffer = Buffer::local(text, cx).with_language(
             Arc::new(Language::new(
                 LanguageConfig {
                     name: "Markdown".into(),
@@ -2150,7 +2142,7 @@ fn test_autoindent_with_injected_languages(cx: &mut App) {
 
         let mut buffer = Buffer::local(text, cx);
         buffer.set_language_registry(language_registry);
-        buffer.set_language_immediate(Some(html_language), cx);
+        buffer.set_language(Some(html_language), cx);
         buffer.edit(
             ranges.into_iter().map(|range| (range, "\na")),
             Some(AutoindentMode::EachLine),
@@ -2184,7 +2176,7 @@ fn test_autoindent_query_with_outdent_captures(cx: &mut App) {
     });
 
     cx.new(|cx| {
-        let mut buffer = Buffer::local("", cx).with_language_immediate(Arc::new(ruby_lang()), cx);
+        let mut buffer = Buffer::local("", cx).with_language(Arc::new(ruby_lang()), cx);
 
         let text = r#"
             class C
@@ -2229,7 +2221,7 @@ async fn test_async_autoindents_preserve_preview(cx: &mut TestAppContext) {
     // Then we request that a preview tab be preserved for the new version, even though it's edited.
     let buffer = cx.new(|cx| {
         let text = "fn a() {}";
-        let mut buffer = Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let mut buffer = Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx);
 
         // This causes autoindent to be async.
         buffer.set_sync_parse_timeout(Duration::ZERO);
@@ -2442,7 +2434,7 @@ fn test_language_scope_at_with_javascript(cx: &mut App) {
         "#
         .unindent();
 
-        let buffer = Buffer::local(&text, cx).with_language_immediate(Arc::new(language), cx);
+        let buffer = Buffer::local(&text, cx).with_language(Arc::new(language), cx);
         let snapshot = buffer.snapshot();
 
         let config = snapshot.language_scope_at(0).unwrap();
@@ -2600,8 +2592,7 @@ fn test_language_scope_at_with_rust(cx: &mut App) {
         "#
         .unindent();
 
-        let buffer =
-            Buffer::local(text.clone(), cx).with_language_immediate(Arc::new(language), cx);
+        let buffer = Buffer::local(text.clone(), cx).with_language(Arc::new(language), cx);
         let snapshot = buffer.snapshot();
 
         // By default, all brackets are enabled
@@ -2647,7 +2638,7 @@ fn test_language_scope_at_with_combined_injections(cx: &mut App) {
 
         let mut buffer = Buffer::local(text, cx);
         buffer.set_language_registry(language_registry.clone());
-        buffer.set_language_immediate(
+        buffer.set_language(
             language_registry
                 .language_for_name("HTML+ERB")
                 .now_or_never()
@@ -2693,7 +2684,7 @@ fn test_language_at_with_hidden_languages(cx: &mut App) {
 
         let mut buffer = Buffer::local(text, cx);
         buffer.set_language_registry(language_registry.clone());
-        buffer.set_language_immediate(
+        buffer.set_language(
             language_registry
                 .language_for_name("Markdown")
                 .now_or_never()
@@ -2736,7 +2727,7 @@ fn test_language_at_for_markdown_code_block(cx: &mut App) {
 
         let mut buffer = Buffer::local(text, cx);
         buffer.set_language_registry(language_registry.clone());
-        buffer.set_language_immediate(
+        buffer.set_language(
             language_registry
                 .language_for_name("Markdown")
                 .now_or_never()
@@ -2789,7 +2780,7 @@ fn test_syntax_layer_at_for_injected_languages(cx: &mut App) {
 
         let mut buffer = Buffer::local(text, cx);
         buffer.set_language_registry(language_registry.clone());
-        buffer.set_language_immediate(
+        buffer.set_language(
             language_registry
                 .language_for_name("HTML+ERB")
                 .now_or_never()
@@ -3129,8 +3120,7 @@ async fn test_preview_edits(cx: &mut TestAppContext) {
         cx: &mut TestAppContext,
         assert_fn: impl Fn(HighlightedText),
     ) {
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let edits = buffer.read_with(cx, |buffer, _| {
             edits
                 .into_iter()
@@ -3541,7 +3531,7 @@ let word=öäpple.bar你 Öäpple word2-öÄpPlE-Pizza-word ÖÄPPLE word
     "#;
 
     let buffer = cx.new(|cx| {
-        let buffer = Buffer::local(contents, cx).with_language_immediate(Arc::new(rust_lang()), cx);
+        let buffer = Buffer::local(contents, cx).with_language(Arc::new(rust_lang()), cx);
         assert_eq!(buffer.text(), contents);
         buffer.check_invariants();
         buffer
@@ -3931,9 +3921,8 @@ fn assert_bracket_pairs(
     cx: &mut App,
 ) {
     let (expected_text, selection_ranges) = marked_text_ranges(selection_text, false);
-    let buffer = cx.new(|cx| {
-        Buffer::local(expected_text.clone(), cx).with_language_immediate(Arc::new(language), cx)
-    });
+    let buffer =
+        cx.new(|cx| Buffer::local(expected_text.clone(), cx).with_language(Arc::new(language), cx));
     let buffer = buffer.update(cx, |buffer, _cx| buffer.snapshot());
 
     let selection_range = selection_ranges[0].clone();

crates/language_tools/src/lsp_log_view.rs

@@ -560,7 +560,7 @@ impl LspLogView {
                         async move |_, cx| {
                             let language = language.await.ok();
                             buffer.update(cx, |buffer, cx| {
-                                buffer.set_language_immediate(language, cx);
+                                buffer.set_language(language, cx);
                             })
                         }
                     })

crates/languages/src/bash.rs

@@ -40,7 +40,7 @@ mod tests {
         });
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             let expect_indents_to =
                 |buffer: &mut Buffer, cx: &mut Context<Buffer>, input: &str, expected: &str| {

crates/languages/src/c.rs

@@ -388,7 +388,7 @@ mod tests {
         let language = crate::language("c", tree_sitter_c::LANGUAGE.into());
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             buffer.edit([(0..0, "int main() {}")], None, cx);
 
@@ -418,7 +418,7 @@ mod tests {
         let language = crate::language("c", tree_sitter_c::LANGUAGE.into());
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             buffer.edit(
                 [(

crates/languages/src/cpp.rs

@@ -20,7 +20,7 @@ mod tests {
         let language = crate::language("cpp", tree_sitter_cpp::LANGUAGE.into());
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             buffer.edit([(0..0, "int main() {}")], None, cx);
 
@@ -50,7 +50,7 @@ mod tests {
         let language = crate::language("cpp", tree_sitter_cpp::LANGUAGE.into());
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             buffer.edit(
                 [(

crates/languages/src/css.rs

@@ -224,8 +224,7 @@ mod tests {
         "#
         .unindent();
 
-        let buffer =
-            cx.new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
         let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
         assert_eq!(
             outline

crates/languages/src/go.rs

@@ -868,9 +868,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(testify_suite, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer = cx
+            .new(|cx| crate::Buffer::local(testify_suite, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {
@@ -927,8 +926,7 @@ mod tests {
         "#;
 
         let buffer = cx.new(|cx| {
-            crate::Buffer::local(interpreted_string_subtest, cx)
-                .with_language_immediate(language.clone(), cx)
+            crate::Buffer::local(interpreted_string_subtest, cx).with_language(language.clone(), cx)
         });
         cx.executor().run_until_parked();
 
@@ -957,8 +955,7 @@ mod tests {
         );
 
         let buffer = cx.new(|cx| {
-            crate::Buffer::local(raw_string_subtest, cx)
-                .with_language_immediate(language.clone(), cx)
+            crate::Buffer::local(raw_string_subtest, cx).with_language(language.clone(), cx)
         });
         cx.executor().run_until_parked();
 
@@ -1002,9 +999,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(example_test, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer =
+            cx.new(|cx| crate::Buffer::local(example_test, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {
@@ -1074,9 +1070,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(table_test, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer =
+            cx.new(|cx| crate::Buffer::local(table_test, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {
@@ -1143,9 +1138,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(table_test, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer =
+            cx.new(|cx| crate::Buffer::local(table_test, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {
@@ -1216,9 +1210,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(table_test, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer =
+            cx.new(|cx| crate::Buffer::local(table_test, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {
@@ -1284,9 +1277,8 @@ mod tests {
         }
         "#;
 
-        let buffer = cx.new(|cx| {
-            crate::Buffer::local(table_test, cx).with_language_immediate(language.clone(), cx)
-        });
+        let buffer =
+            cx.new(|cx| crate::Buffer::local(table_test, cx).with_language(language.clone(), cx));
         cx.executor().run_until_parked();
 
         let runnables: Vec<_> = buffer.update(cx, |buffer, _| {

crates/languages/src/python.rs

@@ -2326,7 +2326,7 @@ mod tests {
         });
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
             let append = |buffer: &mut Buffer, text: &str, cx: &mut Context<Buffer>| {
                 let ix = buffer.len();
                 buffer.edit([(ix..ix, text)], Some(AutoindentMode::EachLine), cx);

crates/languages/src/rust.rs

@@ -1605,7 +1605,7 @@ mod tests {
         let language = crate::language("rust", tree_sitter_rust::LANGUAGE.into());
 
         cx.new(|cx| {
-            let mut buffer = Buffer::local("", cx).with_language_immediate(language, cx);
+            let mut buffer = Buffer::local("", cx).with_language(language, cx);
 
             // indent between braces
             buffer.set_text("fn a() {}", cx);

crates/languages/src/typescript.rs

@@ -895,8 +895,7 @@ mod tests {
         "#
             .unindent();
 
-            let buffer = cx
-                .new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+            let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
             let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
             assert_eq!(
                 outline
@@ -955,8 +954,7 @@ mod tests {
         "#
             .unindent();
 
-            let buffer = cx
-                .new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+            let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
             let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
             assert_eq!(
                 outline
@@ -1028,8 +1026,7 @@ mod tests {
         "#
             .unindent();
 
-            let buffer = cx
-                .new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+            let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
             let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
             assert_eq!(
                 outline
@@ -1109,8 +1106,7 @@ mod tests {
         "#
             .unindent();
 
-            let buffer = cx
-                .new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+            let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
             let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
             assert_eq!(
                 outline
@@ -1181,8 +1177,7 @@ mod tests {
         "#
         .unindent();
 
-        let buffer =
-            cx.new(|cx| language::Buffer::local(text, cx).with_language_immediate(language, cx));
+        let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
         let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
         assert_eq!(
             outline

crates/project/src/buffer_store.rs

@@ -684,9 +684,8 @@ impl LocalBufferStore {
         cx: &mut Context<BufferStore>,
     ) -> Task<Result<Entity<Buffer>>> {
         cx.spawn(async move |buffer_store, cx| {
-            let buffer = cx.new(|cx| {
-                Buffer::local("", cx).with_language_immediate(language::PLAIN_TEXT.clone(), cx)
-            })?;
+            let buffer =
+                cx.new(|cx| Buffer::local("", cx).with_language(language::PLAIN_TEXT.clone(), cx))?;
             buffer_store.update(cx, |buffer_store, cx| {
                 buffer_store.add_buffer(buffer.clone(), cx).log_err();
                 if !project_searchable {
@@ -1592,10 +1591,8 @@ impl BufferStore {
         cx: &mut Context<Self>,
     ) -> Entity<Buffer> {
         let buffer = cx.new(|cx| {
-            Buffer::local(text, cx).with_language_immediate(
-                language.unwrap_or_else(|| language::PLAIN_TEXT.clone()),
-                cx,
-            )
+            Buffer::local(text, cx)
+                .with_language(language.unwrap_or_else(|| language::PLAIN_TEXT.clone()), cx)
         });
 
         self.add_buffer(buffer.clone(), cx).log_err();

crates/project/src/git_store.rs

@@ -3885,7 +3885,7 @@ impl Repository {
                         let git_commit_language =
                             language_registry.language_for_name("Git Commit").await?;
                         buffer.update(&mut cx, |buffer, cx| {
-                            buffer.set_language_immediate(Some(git_commit_language), cx);
+                            buffer.set_language(Some(git_commit_language), cx);
                         })?;
                     }
                     this.update(&mut cx, |this, _| {
@@ -3912,7 +3912,7 @@ impl Repository {
             if let Some(language_registry) = language_registry {
                 let git_commit_language = language_registry.language_for_name("Git Commit").await?;
                 buffer.update(cx, |buffer, cx| {
-                    buffer.set_language_immediate(Some(git_commit_language), cx);
+                    buffer.set_language(Some(git_commit_language), cx);
                 })?;
             }
 

crates/project/src/lsp_store.rs

@@ -4289,8 +4289,9 @@ impl LspStore {
                                 for buffer in buffer_store.buffers() {
                                     if let Some(f) = File::from_dyn(buffer.read(cx).file()).cloned()
                                     {
-                                        buffer
-                                            .update(cx, |buffer, cx| buffer.set_language(None, cx));
+                                        buffer.update(cx, |buffer, cx| {
+                                            buffer.set_language_async(None, cx)
+                                        });
                                         if let Some(local) = this.as_local_mut() {
                                             local.reset_buffer(&buffer, &f, cx);
 
@@ -4413,7 +4414,7 @@ impl LspStore {
                 .language()
                 .is_none_or(|old_language| !Arc::ptr_eq(old_language, &new_language))
             {
-                buffer.set_language(Some(new_language.clone()), cx);
+                buffer.set_language_async(Some(new_language.clone()), cx);
             }
         });
 

crates/repl/src/notebook/cell.rs

@@ -210,7 +210,7 @@ impl Cell {
                     let language = notebook_language.await;
 
                     buffer.update(cx, |buffer, cx| {
-                        buffer.set_language_immediate(language.clone(), cx);
+                        buffer.set_language(language.clone(), cx);
                     });
                 });
 

crates/repl/src/outputs.rs

@@ -282,7 +282,7 @@ impl Output {
                                             );
                                             let buffer = cx.new(|cx| {
                                                 let mut buffer = Buffer::local(full_error, cx)
-                                                    .with_language_immediate(
+                                                    .with_language(
                                                         language::PLAIN_TEXT.clone(),
                                                         cx,
                                                     );

crates/repl/src/outputs/markdown.rs

@@ -60,7 +60,7 @@ impl OutputContent for MarkdownView {
         let buffer = cx.new(|cx| {
             // TODO: Bring in the language registry so we can set the language to markdown
             let mut buffer = Buffer::local(self.raw_text.clone(), cx)
-                .with_language_immediate(language::PLAIN_TEXT.clone(), cx);
+                .with_language(language::PLAIN_TEXT.clone(), cx);
             buffer.set_capability(language::Capability::ReadOnly, cx);
             buffer
         });

crates/repl/src/outputs/plain.rs

@@ -339,8 +339,8 @@ impl OutputContent for TerminalOutput {
         }
 
         let buffer = cx.new(|cx| {
-            let mut buffer = Buffer::local(self.full_text(), cx)
-                .with_language_immediate(language::PLAIN_TEXT.clone(), cx);
+            let mut buffer =
+                Buffer::local(self.full_text(), cx).with_language(language::PLAIN_TEXT.clone(), cx);
             buffer.set_capability(language::Capability::ReadOnly, cx);
             buffer
         });

crates/repl/src/repl_editor.rs

@@ -521,7 +521,7 @@ mod tests {
                 "# },
                 cx,
             )
-            .with_language_immediate(test_language, cx)
+            .with_language(test_language, cx)
         });
         let snapshot = buffer.read(cx).snapshot();
 
@@ -595,7 +595,7 @@ mod tests {
                 "# },
                 cx,
             )
-            .with_language_immediate(test_language, cx)
+            .with_language(test_language, cx)
         });
         let snapshot = buffer.read(cx).snapshot();
 
@@ -716,7 +716,7 @@ mod tests {
                 cx,
             );
             buffer.set_language_registry(language_registry.clone());
-            buffer.set_language_immediate(Some(markdown.clone()), cx);
+            buffer.set_language(Some(markdown.clone()), cx);
             buffer
         });
         let snapshot = buffer.read(cx).snapshot();
@@ -761,7 +761,7 @@ mod tests {
                 cx,
             );
             buffer.set_language_registry(language_registry.clone());
-            buffer.set_language_immediate(Some(markdown.clone()), cx);
+            buffer.set_language(Some(markdown.clone()), cx);
             buffer
         });
         let snapshot = buffer.read(cx).snapshot();
@@ -800,7 +800,7 @@ mod tests {
                 cx,
             );
             buffer.set_language_registry(language_registry.clone());
-            buffer.set_language_immediate(Some(markdown.clone()), cx);
+            buffer.set_language(Some(markdown.clone()), cx);
             buffer
         });
         let snapshot = buffer.read(cx).snapshot();

crates/rules_library/src/rules_library.rs

@@ -715,7 +715,7 @@ impl RulesLibrary {
                         let body_editor = cx.new(|cx| {
                             let buffer = cx.new(|cx| {
                                 let mut buffer = Buffer::local(rule, cx);
-                                buffer.set_language_immediate(markdown.log_err(), cx);
+                                buffer.set_language(markdown.log_err(), cx);
                                 buffer.set_language_registry(language_registry);
                                 buffer
                             });

crates/search/src/buffer_search.rs

@@ -1510,12 +1510,12 @@ impl BufferSearchBar {
         if enable {
             if let Some(regex_language) = self.regex_language.clone() {
                 query_buffer.update(cx, |query_buffer, cx| {
-                    query_buffer.set_language_immediate(Some(regex_language), cx);
+                    query_buffer.set_language(Some(regex_language), cx);
                 })
             }
         } else {
             query_buffer.update(cx, |query_buffer, cx| {
-                query_buffer.set_language_immediate(None, cx);
+                query_buffer.set_language(None, cx);
             })
         }
     }

crates/search/src/project_search.rs

@@ -1654,12 +1654,12 @@ impl ProjectSearchView {
         if enable {
             if let Some(regex_language) = self.regex_language.clone() {
                 query_buffer.update(cx, |query_buffer, cx| {
-                    query_buffer.set_language_immediate(Some(regex_language), cx);
+                    query_buffer.set_language(Some(regex_language), cx);
                 })
             }
         } else {
             query_buffer.update(cx, |query_buffer, cx| {
-                query_buffer.set_language_immediate(None, cx);
+                query_buffer.set_language(None, cx);
             })
         }
     }

crates/tasks_ui/src/tasks_ui.rs

@@ -486,7 +486,7 @@ mod tests {
             .await
             .unwrap();
         buffer1.update(cx, |this, cx| {
-            this.set_language_immediate(Some(typescript_language), cx)
+            this.set_language(Some(typescript_language), cx)
         });
         let editor1 = cx.new_window_entity(|window, cx| {
             Editor::for_buffer(buffer1, Some(project.clone()), window, cx)
@@ -499,9 +499,7 @@ mod tests {
             })
             .await
             .unwrap();
-        buffer2.update(cx, |this, cx| {
-            this.set_language_immediate(Some(rust_language), cx)
-        });
+        buffer2.update(cx, |this, cx| this.set_language(Some(rust_language), cx));
         let editor2 = cx
             .new_window_entity(|window, cx| Editor::for_buffer(buffer2, Some(project), window, cx));
 

crates/vim/src/object.rs

@@ -3244,7 +3244,7 @@ mod test {
             let buffer_ids = multi_buffer.read(cx).excerpt_buffer_ids();
             if let Some(buffer) = multi_buffer.read(cx).buffer(buffer_ids[1]) {
                 buffer.update(cx, |buffer, cx| {
-                    buffer.set_language_immediate(Some(language::rust_lang()), cx);
+                    buffer.set_language(Some(language::rust_lang()), cx);
                 })
             };
 

crates/vim/src/test.rs

@@ -1478,7 +1478,7 @@ async fn test_toggle_comments(cx: &mut gpui::TestAppContext) {
         },
         Some(language::tree_sitter_rust::LANGUAGE.into()),
     ));
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
     // works in normal model
     cx.set_state(
@@ -2363,7 +2363,7 @@ async fn test_wrap_selections_in_tag_line_mode(cx: &mut gpui::TestAppContext) {
         None,
     ));
 
-    cx.update_buffer(|buffer, cx| buffer.set_language_immediate(Some(js_language), cx));
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(js_language), cx));
 
     cx.set_state(
         indoc! {

crates/zed/src/main.rs

@@ -832,7 +832,7 @@ fn handle_open_request(request: OpenRequest, app_state: Arc<AppState>, cx: &mut
 
                             workspace.update_in(cx, |workspace, window, cx| {
                                 buffer.update(cx, |buffer, cx| {
-                                    buffer.set_language_immediate(json, cx);
+                                    buffer.set_language(json, cx);
                                     buffer.edit([(0..0, json_schema_content)], None, cx);
                                     buffer.edit(
                                         [(0..0, format!("// {} JSON Schema\n", schema_path))],

crates/zeta/src/assemble_excerpts.rs

@@ -119,9 +119,8 @@ mod tests {
             let input_without_caret = input.replace('ˇ', "");
             let cursor_offset = input_without_ranges.find('ˇ');
             let (input, ranges) = marked_text_ranges(&input_without_caret, false);
-            let buffer = cx.new(|cx| {
-                Buffer::local(input, cx).with_language_immediate(Arc::new(rust_lang()), cx)
-            });
+            let buffer =
+                cx.new(|cx| Buffer::local(input, cx).with_language(Arc::new(rust_lang()), cx));
             buffer.read_with(cx, |buffer, _cx| {
                 let insertions = cursor_offset
                     .map(|offset| {

crates/zeta/src/zeta1/input_excerpt.rs

@@ -156,8 +156,7 @@ mod tests {
                 numbers
             }
         "#};
-        let buffer =
-            cx.new(|cx| Buffer::local(text, cx).with_language_immediate(Arc::new(rust_lang()), cx));
+        let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
         let snapshot = buffer.read(cx).snapshot();
 
         // Ensure we try to fit the largest possible syntax scope, resorting to line-based expansion

crates/zeta2_tools/src/zeta2_tools.rs

@@ -394,7 +394,7 @@ impl Zeta2Inspector {
                                             let feedback_editor = cx.new(|cx| {
                                                 let buffer = cx.new(|cx| {
                                                     let mut buffer = Buffer::local("", cx);
-                                                    buffer.set_language_immediate(
+                                                    buffer.set_language(
                                                         markdown_language.clone(),
                                                         cx,
                                                     );
@@ -460,10 +460,7 @@ impl Zeta2Inspector {
                                                                 .unwrap_or_default(),
                                                             cx,
                                                         );
-                                                        buffer.set_language_immediate(
-                                                            json_language,
-                                                            cx,
-                                                        );
+                                                        buffer.set_language(json_language, cx);
                                                         buffer
                                                     });
                                                     let buffer = cx.new(|cx| {
@@ -508,7 +505,7 @@ impl Zeta2Inspector {
                             let buffer = cx.new(|cx| {
                                 let mut buffer =
                                     Buffer::local(local_prompt.unwrap_or_else(|err| err), cx);
-                                buffer.set_language_immediate(markdown_language.clone(), cx);
+                                buffer.set_language(markdown_language.clone(), cx);
                                 buffer
                             });
                             let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));