1 files changed, 29 insertions, 19 deletions

diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index 9185e483..2c4fbbfb 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -20,7 +20,7 @@ use helix_core::{
 };
 use helix_lsp::util::LspFormatting;
 
-use crate::{DocumentId, Theme, ViewId};
+use crate::{DocumentId, ViewId};
 
 /// 8kB of buffer space for encoding and decoding `Rope`s.
 const BUF_SIZE: usize = 8192;
@@ -368,8 +368,7 @@ impl Document {
     pub fn open(
         path: &Path,
         encoding: Option<&'static encoding::Encoding>,
-        theme: Option<&Theme>,
-        config_loader: Option<&syntax::Loader>,
+        config_loader: Option<Arc<syntax::Loader>>,
     ) -> Result<Self, Error> {
         // Open the file if it exists, otherwise assume it is a new file (and thus empty).
         let (rope, encoding) = if path.exists() {
@@ -386,7 +385,7 @@ impl Document {
         // set the path and try detecting the language
         doc.set_path(Some(path))?;
         if let Some(loader) = config_loader {
-            doc.detect_language(theme, loader);
+            doc.detect_language(loader);
         }
 
         doc.detect_indent_and_line_ending();
@@ -508,12 +507,12 @@ impl Document {
     }
 
     /// Detect the programming language based on the file type.
-    pub fn detect_language(&mut self, theme: Option<&Theme>, config_loader: &syntax::Loader) {
+    pub fn detect_language(&mut self, config_loader: Arc<syntax::Loader>) {
         if let Some(path) = &self.path {
             let language_config = config_loader
                 .language_config_for_file_name(path)
                 .or_else(|| config_loader.language_config_for_shebang(self.text()));
-            self.set_language(theme, language_config);
+            self.set_language(language_config, Some(config_loader));
         }
     }
 
@@ -587,15 +586,13 @@ impl Document {
     /// if it exists.
     pub fn set_language(
         &mut self,
-        theme: Option<&Theme>,
         language_config: Option<Arc<helix_core::syntax::LanguageConfiguration>>,
+        loader: Option<Arc<helix_core::syntax::Loader>>,
     ) {
-        if let Some(language_config) = language_config {
-            let scopes = theme.map(|theme| theme.scopes()).unwrap_or(&[]);
-            if let Some(highlight_config) = language_config.highlight_config(scopes) {
-                let syntax = Syntax::new(&self.text, highlight_config);
+        if let (Some(language_config), Some(loader)) = (language_config, loader) {
+            if let Some(highlight_config) = language_config.highlight_config(&loader.scopes()) {
+                let syntax = Syntax::new(&self.text, highlight_config, loader);
                 self.syntax = Some(syntax);
-                // TODO: config.configure(scopes) is now delayed, is that ok?
             }
 
             self.language = Some(language_config);
@@ -607,15 +604,10 @@ impl Document {
 
     /// Set the programming language for the file if you know the name (scope) but don't have the
     /// [`syntax::LanguageConfiguration`] for it.
-    pub fn set_language2(
-        &mut self,
-        scope: &str,
-        theme: Option<&Theme>,
-        config_loader: Arc<syntax::Loader>,
-    ) {
+    pub fn set_language2(&mut self, scope: &str, config_loader: Arc<syntax::Loader>) {
         let language_config = config_loader.language_config_for_scope(scope);
 
-        self.set_language(theme, language_config);
+        self.set_language(language_config, Some(config_loader));
     }
 
     /// Set the LSP.
@@ -854,6 +846,24 @@ impl Document {
             .map(|language| language.scope.as_str())
     }
 
+    /// Language ID for the document. Either the `language-id` from the
+    /// `language-server` configuration, or the document language if no
+    /// `language-id` has been specified.
+    pub fn language_id(&self) -> Option<&str> {
+        self.language
+            .as_ref()
+            .and_then(|config| config.language_server.as_ref())
+            .and_then(|lsp_config| lsp_config.language_id.as_ref())
+            .map_or_else(
+                || {
+                    self.language()
+                        .and_then(|s| s.rsplit_once('.'))
+                        .map(|(_, language_id)| language_id)
+                },
+                |language_id| Some(language_id.as_str()),
+            )
+    }
+
     /// Corresponding [`LanguageConfiguration`].
     pub fn language_config(&self) -> Option<&LanguageConfiguration> {
         self.language.as_deref()