Add basic modeline support (#4762)

vim and emacs support "modelines", a comment at the beginning of the
file that allows the file type to be explicitly specified along with
per-file specific settings.

Release Notes:

- Add basic emacs/vim modeline support.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

crates/acp_thread/src/acp_thread.rs

@@ -2145,6 +2145,7 @@ impl AcpThread {
 
                     let settings = language::language_settings::language_settings(
                         buffer.language().map(|l| l.name()),
+                        buffer.modeline().map(Arc::as_ref),
                         buffer.file(),
                         cx,
                     );

crates/acp_thread/src/diff.rs

@@ -383,6 +383,7 @@ async fn build_buffer_diff(
                 old_text_rope,
                 buffer.language().cloned(),
                 language_registry,
+                buffer.modeline().cloned(),
                 cx,
             )
         })?

crates/agent/src/tools/edit_file_tool.rs

@@ -417,6 +417,7 @@ impl AgentTool for EditFileTool {
                 .read_with(cx, |buffer, cx| {
                     let settings = language_settings::language_settings(
                         buffer.language().map(|l| l.name()),
+                        buffer.modeline().map(Arc::as_ref),
                         buffer.file(),
                         cx,
                     );

crates/buffer_diff/src/buffer_diff.rs

@@ -237,8 +237,13 @@ impl BufferDiffSnapshot {
         if let Some(text) = &base_text {
             let base_text_rope = Rope::from(text.as_str());
             base_text_pair = Some((text.clone(), base_text_rope.clone()));
-            let snapshot =
-                language::Buffer::build_snapshot(base_text_rope, language, language_registry, cx);
+            let snapshot = language::Buffer::build_snapshot(
+                base_text_rope,
+                language,
+                language_registry,
+                None,
+                cx,
+            );
             base_text_snapshot = cx.background_spawn(snapshot);
             base_text_exists = true;
         } else {
@@ -855,7 +860,7 @@ fn build_diff_options(
         }
     }
 
-    language_settings(language, file, cx)
+    language_settings(language, None, file, cx)
         .word_diff_enabled
         .then_some(DiffOptions {
             language_scope,

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -161,8 +161,10 @@ async fn test_sharing_an_ssh_remote_project(
 
     cx_b.read(|cx| {
         let file = buffer_b.read(cx).file();
+        let modeline = buffer_b.read(cx).modeline();
         assert_eq!(
-            language_settings(Some("Rust".into()), file, cx).language_servers,
+            language_settings(Some("Rust".into()), modeline.map(Arc::as_ref), file, cx)
+                .language_servers,
             ["override-rust-analyzer".to_string()]
         )
     });

crates/copilot/src/copilot.rs

@@ -968,6 +968,7 @@ impl Copilot {
         let position = position.to_point_utf16(buffer);
         let settings = language_settings(
             buffer.language_at(position).map(|l| l.name()),
+            buffer.modeline().map(Arc::as_ref),
             buffer.file(),
             cx,
         );

crates/debugger_ui/src/new_process_modal.rs

@@ -1277,22 +1277,28 @@ impl PickerDelegate for DebugDelegate {
         };
         let file = location.buffer.read(cx).file();
         let language = location.buffer.read(cx).language();
+        let modeline = location.buffer.read(cx).modeline();
         let language_name = language.as_ref().map(|l| l.name());
         let Some(adapter): Option<DebugAdapterName> =
-            language::language_settings::language_settings(language_name, file, cx)
-                .debuggers
-                .first()
-                .map(SharedString::from)
-                .map(Into::into)
-                .or_else(|| {
-                    language.and_then(|l| {
-                        l.config()
-                            .debuggers
-                            .first()
-                            .map(SharedString::from)
-                            .map(Into::into)
-                    })
+            language::language_settings::language_settings(
+                language_name,
+                modeline.map(Arc::as_ref),
+                file,
+                cx,
+            )
+            .debuggers
+            .first()
+            .map(SharedString::from)
+            .map(Into::into)
+            .or_else(|| {
+                language.and_then(|l| {
+                    l.config()
+                        .debuggers
+                        .first()
+                        .map(SharedString::from)
+                        .map(Into::into)
                 })
+            })
         else {
             return;
         };

crates/edit_prediction_context/src/edit_prediction_context_tests.rs

@@ -517,6 +517,7 @@ pub(crate) fn rust_lang() -> Arc<Language> {
                 matcher: LanguageMatcher {
                     path_suffixes: vec!["rs".to_string()],
                     first_line_pattern: None,
+                    ..LanguageMatcher::default()
                 },
                 ..Default::default()
             },

crates/edit_prediction_ui/src/edit_prediction_button.rs

@@ -694,7 +694,7 @@ impl EditPredictionButton {
         let language_state = self.language.as_ref().map(|language| {
             (
                 language.clone(),
-                language_settings::language_settings(Some(language.name()), None, cx)
+                language_settings::language_settings(Some(language.name()), None, None, cx)
                     .show_edit_predictions,
             )
         });

crates/editor/src/bracket_colorization.rs

@@ -3,6 +3,7 @@
 //! and theme accents to colorize those.
 
 use std::ops::Range;
+use std::sync::Arc;
 
 use crate::Editor;
 use collections::HashMap;
@@ -49,6 +50,7 @@ impl Editor {
                 let buffer_snapshot = buffer.read(cx).snapshot();
                 if language_settings::language_settings(
                     buffer_snapshot.language().map(|language| language.name()),
+                    buffer_snapshot.modeline().map(Arc::as_ref),
                     buffer_snapshot.file(),
                     cx,
                 )