Add vim/emacs modeline support

assets/settings/default.json

@@ -1216,6 +1216,12 @@
   "hard_tabs": false,
   // How many columns a tab should occupy.
   "tab_size": 4,
+  // Number of lines to search for modelines at the beginning and end of files.
+  // Modelines contain editor directives (e.g., vim/emacs settings) that configure
+  // the editor behavior for specific files.
+  //
+  // A value of 0 disables modelines support.
+  "modeline_lines": 5,
   // What debuggers are preferred by default for all languages.
   "debuggers": [],
   // Whether to enable word diff highlighting in the editor.

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,
                 )

crates/editor/src/display_map.rs

@@ -632,7 +632,8 @@ impl DisplayMap {
             .and_then(|buffer| buffer.language())
             .map(|l| l.name());
         let file = buffer.and_then(|buffer| buffer.file());
-        language_settings(language, file, cx).tab_size
+        let modeline = buffer.and_then(|buffer| buffer.modeline());
+        language_settings(language, modeline.map(Arc::as_ref), file, cx).tab_size
     }
 
     #[cfg(test)]

crates/editor/src/editor.rs

@@ -576,7 +576,7 @@ impl Default for EditorStyle {
 }
 
 pub fn make_inlay_hints_style(cx: &mut App) -> HighlightStyle {
-    let show_background = language_settings::language_settings(None, None, cx)
+    let show_background = language_settings::language_settings(None, None, None, cx)
         .inlay_hints
         .show_background;
 
@@ -5406,11 +5406,13 @@ impl Editor {
             .read(cx)
             .text_anchor_for_position(position, cx)?;
 
+        let modeline = buffer.read(cx).modeline();
         let settings = language_settings::language_settings(
             buffer
                 .read(cx)
                 .language_at(buffer_position)
                 .map(|l| l.name()),
+            modeline.map(Arc::as_ref),
             buffer.read(cx).file(),
             cx,
         );
@@ -5530,7 +5532,12 @@ impl Editor {
             .language_at(buffer_position.text_anchor)
             .map(|language| language.name());
 
-        let language_settings = language_settings(language.clone(), buffer_snapshot.file(), cx);
+        let language_settings = language_settings(
+            language.clone(),
+            buffer_snapshot.modeline().map(Arc::as_ref),
+            buffer_snapshot.file(),
+            cx,
+        );
         let completion_settings = language_settings.completions.clone();
 
         if !menu_is_open && trigger.is_some() && !language_settings.show_completions_on_input {
@@ -6408,11 +6415,13 @@ impl Editor {
             let buffer = buffer.read(cx);
             let language = buffer.language()?;
             let file = buffer.file();
-            let debug_adapter = language_settings(language.name().into(), file, cx)
-                .debuggers
-                .first()
-                .map(SharedString::from)
-                .or_else(|| language.config().debuggers.first().map(SharedString::from))?;
+            let modeline = buffer.modeline();
+            let debug_adapter =
+                language_settings(language.name().into(), modeline.map(Arc::as_ref), file, cx)
+                    .debuggers
+                    .first()
+                    .map(SharedString::from)
+                    .or_else(|| language.config().debuggers.first().map(SharedString::from))?;
 
             dap_store.update(cx, |dap_store, cx| {
                 for (_, task) in &resolved_tasks.templates {
@@ -7380,8 +7389,16 @@ impl Editor {
         let buffer = buffer.read(cx);
 
         let file = buffer.file();
+        let modeline = buffer.modeline();
 
-        if !language_settings(buffer.language().map(|l| l.name()), file, cx).show_edit_predictions {
+        if !language_settings(
+            buffer.language().map(|l| l.name()),
+            modeline.map(Arc::as_ref),
+            file,
+            cx,
+        )
+        .show_edit_predictions
+        {
             return EditPredictionSettings::Disabled;
         };
 
@@ -21782,7 +21799,11 @@ impl Editor {
                 let language = buffer.language().map(|language| language.name());
                 if let hash_map::Entry::Vacant(v) = acc.entry(language.clone()) {
                     let file = buffer.file();
-                    v.insert(language_settings(language, file, cx).into_owned());
+                    let modeline = buffer.modeline();
+                    v.insert(
+                        language_settings(language, modeline.map(Arc::as_ref), file, cx)
+                            .into_owned(),
+                    );
                 }
                 acc
             },
@@ -22907,10 +22928,14 @@ fn process_completion_for_edit(
                 CompletionIntent::CompleteWithInsert => false,
                 CompletionIntent::CompleteWithReplace => true,
                 CompletionIntent::Complete | CompletionIntent::Compose => {
-                    let insert_mode =
-                        language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx)
-                            .completions
-                            .lsp_insert_mode;
+                    let insert_mode = language_settings(
+                        buffer.language().map(|l| l.name()),
+                        buffer.modeline().map(Arc::as_ref),
+                        buffer.file(),
+                        cx,
+                    )
+                    .completions
+                    .lsp_insert_mode;
                     match insert_mode {
                         LspInsertMode::Insert => false,
                         LspInsertMode::Replace => true,

crates/editor/src/indent_guides.rs

@@ -1,4 +1,4 @@
-use std::{cmp::Ordering, ops::Range, time::Duration};
+use std::{cmp::Ordering, ops::Range, sync::Arc, time::Duration};
 
 use collections::HashSet;
 use gpui::{App, AppContext as _, Context, Task, Window};
@@ -39,6 +39,7 @@ impl Editor {
             if let Some(buffer) = self.buffer().read(cx).as_singleton() {
                 language_settings(
                     buffer.read(cx).language().map(|l| l.name()),
+                    buffer.read(cx).modeline().map(Arc::as_ref),
                     buffer.read(cx).file(),
                     cx,
                 )

crates/editor/src/inlays/inlay_hints.rs

@@ -1,6 +1,7 @@
 use std::{
     collections::hash_map,
     ops::{ControlFlow, Range},
+    sync::Arc,
     time::Duration,
 };
 
@@ -38,7 +39,8 @@ pub fn inlay_hint_settings(
 ) -> InlayHintSettings {
     let file = snapshot.file_at(location);
     let language = snapshot.language_at(location).map(|l| l.name());
-    language_settings(language, file, cx).inlay_hints
+    let modeline = snapshot.modeline_at(location);
+    language_settings(language, modeline.map(Arc::as_ref), file, cx).inlay_hints
 }
 
 #[derive(Debug)]

crates/editor/src/jsx_tag_auto_close.rs

@@ -3,6 +3,7 @@ use collections::HashMap;
 use gpui::{Context, Entity, Window};
 use multi_buffer::{BufferOffset, MultiBuffer, ToOffset};
 use std::ops::Range;
+use std::sync::Arc;
 use util::ResultExt as _;
 
 use language::{BufferSnapshot, JsxTagAutoCloseConfig, Node};
@@ -318,13 +319,15 @@ pub(crate) fn refresh_enabled_in_any_buffer(
 
             let buffer = buffer.read(cx);
             let snapshot = buffer.snapshot();
+            let modeline = buffer.modeline();
             for syntax_layer in snapshot.syntax_layers() {
                 let language = syntax_layer.language;
                 if language.config().jsx_tag_auto_close.is_none() {
                     continue;
                 }
                 let language_settings = language::language_settings::language_settings(
                     Some(language.name()),
+                    modeline.map(Arc::as_ref),
                     snapshot.file(),
                     cx,
                 );

crates/extension_host/src/extension_store_test.rs

@@ -214,6 +214,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                     matcher: LanguageMatcher {
                         path_suffixes: vec!["erb".into()],
                         first_line_pattern: None,
+                        ..LanguageMatcher::default()
                     },
                 },
             ),
@@ -227,6 +228,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                     matcher: LanguageMatcher {
                         path_suffixes: vec!["rb".into()],
                         first_line_pattern: None,
+                        ..LanguageMatcher::default()
                     },
                 },
             ),

crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs

@@ -440,6 +440,7 @@ impl ExtensionImports for WasmState {
                         let settings = AllLanguageSettings::get(location, cx).language(
                             location,
                             key.as_ref(),
+                            None,
                             cx,
                         );
                         Ok(serde_json::to_string(&settings::LanguageSettings {

crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs

@@ -933,6 +933,7 @@ impl ExtensionImports for WasmState {
                         let settings = AllLanguageSettings::get(location, cx).language(
                             location,
                             key.as_ref(),
+                            None,
                             cx,
                         );
                         Ok(serde_json::to_string(&settings::LanguageSettings {

crates/git_ui/src/commit_view.rs

@@ -824,6 +824,7 @@ async fn build_buffer_diff(
                 old_text.as_deref().unwrap_or("").into(),
                 buffer.language().cloned(),
                 Some(language_registry.clone()),
+                buffer.modeline().cloned(),
                 cx,
             )
         })?