Make language_settings take a language, not a language name

crates/copilot/src/copilot.rs

@@ -785,11 +785,7 @@ impl Copilot {
         let buffer = buffer.read(cx);
         let uri = registered_buffer.uri.clone();
         let position = position.to_point_utf16(buffer);
-        let settings = language_settings(
+        let settings = language_settings(buffer.language_at(position).as_ref(), buffer.file(), cx);
-            buffer.language_at(position).map(|l| l.name()).as_deref(),
-            buffer.file(),
-            cx,
-        );
         let tab_size = settings.tab_size;
         let hard_tabs = settings.hard_tabs;
         let relative_path = buffer

crates/copilot_button/src/copilot_button.rs

@@ -11,7 +11,7 @@ use gpui::{
 };
 use language::{
     language_settings::{self, all_language_settings, AllLanguageSettings},
-    File,
+    File, Language,
 };
 use settings::{update_settings_file, SettingsStore};
 use std::{path::Path, sync::Arc};
@@ -29,7 +29,7 @@ pub struct CopilotButton {
     popup_menu: ViewHandle<ContextMenu>,
     editor_subscription: Option<(Subscription, usize)>,
     editor_enabled: Option<bool>,
-    language: Option<Arc<str>>,
+    language: Option<Arc<Language>>,
     file: Option<Arc<dyn File>>,
     fs: Arc<dyn Fs>,
 }
@@ -200,14 +200,13 @@ impl CopilotButton {
 
         if let Some(language) = self.language.clone() {
             let fs = fs.clone();
-            let language_enabled =
+            let language_enabled = language_settings::language_settings(Some(&language), None, cx)
-                language_settings::language_settings(Some(language.as_ref()), None, cx)
                 .show_copilot_suggestions;
             menu_options.push(ContextMenuItem::handler(
                 format!(
                     "{} Suggestions for {}",
                     if language_enabled { "Hide" } else { "Show" },
-                    language
+                    language.name()
                 ),
                 move |cx| toggle_copilot_for_language(language.clone(), fs.clone(), cx),
             ));
@@ -279,18 +278,14 @@ impl CopilotButton {
         let editor = editor.read(cx);
         let snapshot = editor.buffer().read(cx).snapshot(cx);
         let suggestion_anchor = editor.selections.newest_anchor().start;
-        let language_name = snapshot
+        let language = snapshot.language_at(suggestion_anchor);
-            .language_at(suggestion_anchor)
-            .map(|language| language.name());
         let file = snapshot.file_at(suggestion_anchor).cloned();
 
         self.editor_enabled = Some(
-            all_language_settings(self.file.as_ref(), cx).copilot_enabled(
+            all_language_settings(self.file.as_ref(), cx)
-                language_name.as_deref(),
+                .copilot_enabled(language, file.as_ref().map(|file| file.path().as_ref())),
-                file.as_ref().map(|file| file.path().as_ref()),
-            ),
         );
-        self.language = language_name;
+        self.language = language.cloned();
         self.file = file;
 
         cx.notify()
@@ -374,12 +369,12 @@ fn toggle_copilot_globally(fs: Arc<dyn Fs>, cx: &mut AppContext) {
     });
 }
 
-fn toggle_copilot_for_language(language: Arc<str>, fs: Arc<dyn Fs>, cx: &mut AppContext) {
+fn toggle_copilot_for_language(language: Arc<Language>, fs: Arc<dyn Fs>, cx: &mut AppContext) {
     let show_copilot_suggestions =
         all_language_settings(None, cx).copilot_enabled(Some(&language), None);
     update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
         file.languages
-            .entry(language)
+            .entry(language.name())
             .or_default()
             .show_copilot_suggestions = Some(!show_copilot_suggestions);
     });

crates/editor/src/display_map.rs

@@ -272,12 +272,11 @@ impl DisplayMap {
     }
 
     fn tab_size(buffer: &ModelHandle<MultiBuffer>, cx: &mut ModelContext<Self>) -> NonZeroU32 {
-        let language_name = buffer
+        let language = buffer
             .read(cx)
             .as_singleton()
-            .and_then(|buffer| buffer.read(cx).language())
+            .and_then(|buffer| buffer.read(cx).language());
-            .map(|language| language.name());
+        language_settings(language.as_deref(), None, cx).tab_size
-        language_settings(language_name.as_deref(), None, cx).tab_size
     }
 
     #[cfg(test)]

crates/editor/src/editor.rs

@@ -3208,11 +3208,9 @@ impl Editor {
         cx: &mut ViewContext<Self>,
     ) -> bool {
         let file = snapshot.file_at(location);
-        let language_name = snapshot
+        let language = snapshot.language_at(location);
-            .language_at(location)
-            .map(|language| language.name());
         let settings = all_language_settings(file, cx);
-        settings.copilot_enabled(language_name.as_deref(), file.map(|f| f.path().as_ref()))
+        settings.copilot_enabled(language, file.map(|f| f.path().as_ref()))
     }
 
     fn has_active_copilot_suggestion(&self, cx: &AppContext) -> bool {

crates/editor/src/multi_buffer.rs

@@ -1381,10 +1381,10 @@ impl MultiBuffer {
         let mut file = None;
         if let Some((buffer, offset)) = self.point_to_buffer_offset(point, cx) {
             let buffer = buffer.read(cx);
-            language = buffer.language_at(offset).map(|l| l.name());
+            language = buffer.language_at(offset);
             file = buffer.file();
         }
-        language_settings(language.as_deref(), file, cx)
+        language_settings(language.as_ref(), file, cx)
     }
 
     pub fn for_each_buffer(&self, mut f: impl FnMut(&ModelHandle<Buffer>)) {
@@ -2794,10 +2794,10 @@ impl MultiBufferSnapshot {
         let mut language = None;
         let mut file = None;
         if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
-            language = buffer.language_at(offset).map(|l| l.name());
+            language = buffer.language_at(offset);
             file = buffer.file();
         }
-        language_settings(language.as_deref(), file, cx)
+        language_settings(language, file, cx)
     }
 
     pub fn language_scope_at<'a, T: ToOffset>(&'a self, point: T) -> Option<LanguageScope> {

crates/language/src/buffer.rs

@@ -1807,8 +1807,7 @@ impl BufferSnapshot {
     }
 
     pub fn language_indent_size_at<T: ToOffset>(&self, position: T, cx: &AppContext) -> IndentSize {
-        let language_name = self.language_at(position).map(|language| language.name());
+        let settings = language_settings(self.language_at(position), self.file(), cx);
-        let settings = language_settings(language_name.as_deref(), self.file(), cx);
         if settings.hard_tabs {
             IndentSize::tab()
         } else {
@@ -2132,12 +2131,7 @@ impl BufferSnapshot {
         position: D,
         cx: &'a AppContext,
     ) -> &'a LanguageSettings {
-        let language = self.language_at(position);
+        language_settings(self.language_at(position), self.file.as_ref(), cx)
-        language_settings(
-            language.map(|l| l.name()).as_deref(),
-            self.file.as_ref(),
-            cx,
-        )
     }
 
     pub fn language_scope_at<D: ToOffset>(&self, position: D) -> Option<LanguageScope> {

crates/language/src/language_settings.rs

@@ -1,4 +1,4 @@
-use crate::File;
+use crate::{File, Language};
 use anyhow::Result;
 use collections::HashMap;
 use globset::GlobMatcher;
@@ -15,7 +15,7 @@ pub fn init(cx: &mut AppContext) {
 }
 
 pub fn language_settings<'a>(
-    language: Option<&str>,
+    language: Option<&Arc<Language>>,
     file: Option<&Arc<dyn File>>,
     cx: &'a AppContext,
 ) -> &'a LanguageSettings {
@@ -23,7 +23,7 @@ pub fn language_settings<'a>(
         file.map(|f| (f.worktree_id(), f.path().as_ref())),
         cx,
     )
-    .language(language)
+    .language(language.map(|l| l.name()).as_deref())
 }
 
 pub fn all_language_settings<'a>(
@@ -170,7 +170,7 @@ impl AllLanguageSettings {
             .any(|glob| glob.is_match(path))
     }
 
-    pub fn copilot_enabled(&self, language_name: Option<&str>, path: Option<&Path>) -> bool {
+    pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
         if !self.copilot.feature_enabled {
             return false;
         }
@@ -181,7 +181,8 @@ impl AllLanguageSettings {
             }
         }
 
-        self.language(language_name).show_copilot_suggestions
+        self.language(language.map(|l| l.name()).as_deref())
+            .show_copilot_suggestions
     }
 }
 

crates/project/src/lsp_command.rs

@@ -1716,8 +1716,7 @@ impl LspCommand for OnTypeFormatting {
             .await?;
 
         let tab_size = buffer.read_with(&cx, |buffer, cx| {
-            let language_name = buffer.language().map(|language| language.name());
+            language_settings(buffer.language(), buffer.file(), cx).tab_size
-            language_settings(language_name.as_deref(), buffer.file(), cx).tab_size
         });
 
         Ok(Self {

crates/project/src/project.rs

@@ -694,8 +694,7 @@ impl Project {
             if let Some(buffer) = buffer.upgrade(cx) {
                 let buffer = buffer.read(cx);
                 if let Some((file, language)) = buffer.file().zip(buffer.language()) {
-                    let settings =
+                    let settings = language_settings(Some(language), Some(file), cx);
-                        language_settings(Some(language.name().as_ref()), Some(file), cx);
                     if settings.enable_language_server {
                         if let Some(file) = File::from_dyn(Some(file)) {
                             language_servers_to_start
@@ -719,9 +718,7 @@ impl Project {
                 let file = worktree.and_then(|tree| {
                     tree.update(cx, |tree, cx| tree.root_file(cx).map(|f| f as _))
                 });
-                if !language_settings(Some(&language.name()), file.as_ref(), cx)
+                if !language_settings(Some(language), file.as_ref(), cx).enable_language_server {
-                    .enable_language_server
-                {
                     language_servers_to_stop.push((*worktree_id, started_lsp_name.clone()));
                 }
             }
@@ -2361,7 +2358,7 @@ impl Project {
         cx: &mut ModelContext<Self>,
     ) {
         if !language_settings(
-            Some(&language.name()),
+            Some(&language),
             worktree
                 .update(cx, |tree, cx| tree.root_file(cx))
                 .map(|f| f as _)
@@ -3465,8 +3462,7 @@ impl Project {
                 let mut project_transaction = ProjectTransaction::default();
                 for (buffer, buffer_abs_path, language_server) in &buffers_with_paths_and_servers {
                     let settings = buffer.read_with(&cx, |buffer, cx| {
-                        let language_name = buffer.language().map(|language| language.name());
+                        language_settings(buffer.language(), buffer.file(), cx).clone()
-                        language_settings(language_name.as_deref(), buffer.file(), cx).clone()
                     });
 
                     let remove_trailing_whitespace = settings.remove_trailing_whitespace_on_save;
@@ -4477,10 +4473,10 @@ impl Project {
     ) -> Task<Result<Option<Transaction>>> {
         let (position, tab_size) = buffer.read_with(cx, |buffer, cx| {
             let position = position.to_point_utf16(buffer);
-            let language_name = buffer.language_at(position).map(|l| l.name());
             (
                 position,
-                language_settings(language_name.as_deref(), buffer.file(), cx).tab_size,
+                language_settings(buffer.language_at(position).as_ref(), buffer.file(), cx)
+                    .tab_size,
             )
         });
         self.request_lsp(

crates/zed/src/languages/yaml.rs

@@ -3,7 +3,7 @@ use async_trait::async_trait;
 use futures::{future::BoxFuture, FutureExt, StreamExt};
 use gpui::AppContext;
 use language::{
-    language_settings::language_settings, LanguageServerBinary, LanguageServerName, LspAdapter,
+    language_settings::all_language_settings, LanguageServerBinary, LanguageServerName, LspAdapter,
 };
 use node_runtime::NodeRuntime;
 use serde_json::Value;
@@ -101,13 +101,16 @@ impl LspAdapter for YamlLspAdapter {
     }
 
     fn workspace_configuration(&self, cx: &mut AppContext) -> Option<BoxFuture<'static, Value>> {
+        let tab_size = all_language_settings(None, cx)
+            .language(Some("YAML"))
+            .tab_size;
         Some(
             future::ready(serde_json::json!({
                 "yaml": {
                     "keyOrdering": false
                 },
                 "[yaml]": {
-                    "editor.tabSize": language_settings(Some("YAML"), None, cx).tab_size,
+                    "editor.tabSize": tab_size,
                 }
             }))
             .boxed(),