Split global and document settings

lionel- · lionel- · commit fe8b0a6172b8 · 2025-07-22T12:07:03.000+02:00
diff --git a/crates/ark/src/lsp/config.rs b/crates/ark/src/lsp/config.rs
@@ -4,21 +4,45 @@ use serde_json::Value;
 
 use crate::lsp::diagnostics::DiagnosticsConfig;
 
-pub struct Setting {
+pub struct Setting<T> {
     pub key: &'static str,
-    pub set: fn(&mut LspConfig, Value),
+    pub set: fn(&mut T, Value),
 }
 
-// List of LSP settings for which clients can send `didChangeConfiguration`
-// notifications. We register our interest in watching over these settings in
-// our `initialized` handler. The `set` methods convert from a json `Value` to
-// the expected type, using a default value if the conversion fails.
-pub static SETTINGS: &[Setting] = &[
+/// List of LSP settings for which clients can send `didChangeConfiguration`
+/// notifications. We register our interest in watching over these settings in
+/// our `initialized` handler. The `set` methods convert from a json `Value` to
+/// the expected type, using a default value if the conversion fails.
+///
+/// This array is for global settings. If the setting should only affect a given
+/// document URI, add it to `DOCUMENT_SETTINGS` instead.
+pub static GLOBAL_SETTINGS: &[Setting<LspConfig>] = &[
+    Setting {
+        key: "positron.r.diagnostics.enable",
+        set: |cfg, v| {
+            cfg.diagnostics.enable = v
+                .as_bool()
+                .unwrap_or_else(|| DiagnosticsConfig::default().enable)
+        },
+    },
+    Setting {
+        key: "positron.r.symbols.includeAssignmentsInBlocks",
+        set: |cfg, v| {
+            cfg.symbols.include_assignments_in_blocks = v
+                .as_bool()
+                .unwrap_or_else(|| SymbolsConfig::default().include_assignments_in_blocks)
+        },
+    },
+];
+
+/// These document settings are updated on a URI basis. Each document has its
+/// own value of the setting.
+pub static DOCUMENT_SETTINGS: &[Setting<DocumentConfig>] = &[
     Setting {
         key: "editor.insertSpaces",
         set: |cfg, v| {
             let default_style = IndentationConfig::default().indent_style;
-            cfg.document.indent.indent_style = if v
+            cfg.indent.indent_style = if v
                 .as_bool()
                 .unwrap_or_else(|| default_style == IndentStyle::Space)
             {
@@ -31,7 +55,7 @@ pub static SETTINGS: &[Setting] = &[
     Setting {
         key: "editor.indentSize",
         set: |cfg, v| {
-            cfg.document.indent.indent_size = v
+            cfg.indent.indent_size = v
                 .as_u64()
                 .map(|n| n as usize)
                 .unwrap_or_else(|| IndentationConfig::default().indent_size)
@@ -40,36 +64,19 @@ pub static SETTINGS: &[Setting] = &[
     Setting {
         key: "editor.tabSize",
         set: |cfg, v| {
-            cfg.document.indent.tab_width = v
+            cfg.indent.tab_width = v
                 .as_u64()
                 .map(|n| n as usize)
                 .unwrap_or_else(|| IndentationConfig::default().tab_width)
         },
     },
-    Setting {
-        key: "positron.r.diagnostics.enable",
-        set: |cfg, v| {
-            cfg.diagnostics.enable = v
-                .as_bool()
-                .unwrap_or_else(|| DiagnosticsConfig::default().enable)
-        },
-    },
-    Setting {
-        key: "positron.r.symbols.includeAssignmentsInBlocks",
-        set: |cfg, v| {
-            cfg.symbols.include_assignments_in_blocks = v
-                .as_bool()
-                .unwrap_or_else(|| SymbolsConfig::default().include_assignments_in_blocks)
-        },
-    },
 ];
 
 /// Configuration of the LSP
 #[derive(Clone, Default, Debug)]
 pub(crate) struct LspConfig {
     pub(crate) diagnostics: DiagnosticsConfig,
     pub(crate) symbols: SymbolsConfig,
-    pub(crate) document: DocumentConfig,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
diff --git a/crates/ark/src/lsp/handlers.rs b/crates/ark/src/lsp/handlers.rs
@@ -103,7 +103,14 @@ pub(crate) async fn handle_initialized(
         // changed by extensions or by the user without changing the actual
         // underlying setting. Unfortunately we don't receive updates in that case.
 
-        for setting in crate::lsp::config::SETTINGS {
+        for setting in crate::lsp::config::GLOBAL_SETTINGS {
+            regs.push(Registration {
+                id: uuid::Uuid::new_v4().to_string(),
+                method: String::from("workspace/didChangeConfiguration"),
+                register_options: Some(serde_json::json!({ "section": setting.key })),
+            });
+        }
+        for setting in crate::lsp::config::DOCUMENT_SETTINGS {
             regs.push(Registration {
                 id: uuid::Uuid::new_v4().to_string(),
                 method: String::from("workspace/didChangeConfiguration"),
diff --git a/crates/ark/src/lsp/state_handlers.rs b/crates/ark/src/lsp/state_handlers.rs
@@ -8,6 +8,7 @@
 use std::path::Path;
 
 use anyhow::anyhow;
+use tower_lsp::lsp_types;
 use tower_lsp::lsp_types::CompletionOptions;
 use tower_lsp::lsp_types::CompletionOptionsCompletionItem;
 use tower_lsp::lsp_types::DidChangeConfigurationParams;
@@ -39,7 +40,8 @@ use url::Url;
 use crate::lsp;
 use crate::lsp::capabilities::Capabilities;
 use crate::lsp::config::indent_style_from_lsp;
-use crate::lsp::config::SETTINGS;
+use crate::lsp::config::DOCUMENT_SETTINGS;
+use crate::lsp::config::GLOBAL_SETTINGS;
 use crate::lsp::documents::Document;
 use crate::lsp::encoding::get_position_encoding_kind;
 use crate::lsp::indexer;
@@ -277,34 +279,76 @@ pub(crate) fn did_change_formatting_options(
 }
 
 async fn update_config(
-    _uris: Vec<Url>,
+    uris: Vec<Url>,
     client: &tower_lsp::Client,
     state: &mut WorldState,
 ) -> anyhow::Result<()> {
-    // Build the configuration request for global settings
-    let items: Vec<_> = SETTINGS
+    // Build the configuration request for global and document settings
+    let mut items: Vec<_> = vec![];
+
+    // This should be first because we first handle the global settings below,
+    // splitting them off the response array
+    let mut global_items: Vec<_> = GLOBAL_SETTINGS
         .iter()
-        .map(|mapping| tower_lsp::lsp_types::ConfigurationItem {
+        .map(|mapping| lsp_types::ConfigurationItem {
             scope_uri: None,
             section: Some(mapping.key.to_string()),
         })
         .collect();
 
-    let configs = client.configuration(items).await?;
+    // For document items we create a n_uris * n_document_settings array that we'll
+    // handle by batch in a double loop over URIs and document settings
+    let mut document_items: Vec<_> = uris
+        .iter()
+        .flat_map(|uri| {
+            DOCUMENT_SETTINGS
+                .iter()
+                .map(|mapping| lsp_types::ConfigurationItem {
+                    scope_uri: Some(uri.clone()),
+                    section: Some(mapping.key.to_string()),
+                })
+        })
+        .collect();
+
+    // Concatenate everything into a flat array that we'll send in one request
+    items.append(&mut global_items);
+    items.append(&mut document_items);
+
+    // The response better match the number of items we send in
+    let n_items = items.len();
+
+    let mut configs = client.configuration(items).await?;
 
-    if configs.len() != SETTINGS.len() {
+    if configs.len() != n_items {
         return Err(anyhow!(
             "Unexpected number of retrieved configurations: {}/{}",
             configs.len(),
-            SETTINGS.len()
+            n_items
         ));
     }
 
-    // Apply each config value using its update closure
-    for (mapping, value) in SETTINGS.iter().zip(configs) {
+    let document_configs = configs.split_off(GLOBAL_SETTINGS.len());
+    let global_configs = configs;
+
+    for (mapping, value) in GLOBAL_SETTINGS.into_iter().zip(global_configs) {
         (mapping.set)(&mut state.config, value);
     }
 
+    let mut remaining = document_configs;
+
+    for uri in uris.into_iter() {
+        // Need to juggle a bit because `split_off()` returns the tail of the
+        // split and updates the vector with the head
+        let tail = remaining.split_off(DOCUMENT_SETTINGS.len());
+        let head = std::mem::replace(&mut remaining, tail);
+
+        for (mapping, value) in DOCUMENT_SETTINGS.iter().zip(head) {
+            if let Ok(doc) = state.get_document_mut(&uri) {
+                (mapping.set)(&mut doc.config, value);
+            }
+        }
+    }
+
     Ok(())
 }
 
