Support InitializationOptions.settings

Allows configuration at startup

Author: alexheretic

src/actions/hover.rs

@@ -1186,8 +1186,7 @@ pub mod test {
                 true,
             );
 
-            let init_options = InitializationOptions::default();
-            ctx.init(&init_options, output);
+            ctx.init(InitializationOptions::default(), output);
             ctx.build(&project_dir, BuildPriority::Immediate, output);
 
             TooltipTestHarness {

src/actions/mod.rs

@@ -89,7 +89,7 @@ impl ActionContext {
     pub fn init<O: Output>(
         &mut self,
         current_project: PathBuf,
-        init_options: &InitializationOptions,
+        init_options: InitializationOptions,
         client_capabilities: lsp_data::ClientCapabilities,
         out: &O,
     ) -> Result<(), ()> {
@@ -306,20 +306,27 @@ impl InitActionContext {
         }
     }
 
-    fn init<O: Output>(&self, init_options: &InitializationOptions, out: &O) {
+    fn init<O: Output>(&self, init_options: InitializationOptions, out: &O) {
         let current_project = self.current_project.clone();
-        let config = self.config.clone();
-        // Spawn another thread since we're shelling out to Cargo and this can
-        // cause a non-trivial amount of time due to disk access
-        thread::spawn(move || {
-            let mut config = config.lock().unwrap();
-            if let Err(e) = config.infer_defaults(&current_project) {
-                debug!(
-                    "Encountered an error while trying to infer config defaults: {:?}",
-                    e
-                );
-            }
-        });
+
+        if let Some(config) = init_options.settings.map(|s| s.rust) {
+            self.config.lock().unwrap().update(config);
+        }
+
+        if self.config.lock().unwrap().needs_inference() {
+            let config = Arc::clone(&self.config);
+            // Spawn another thread since we're shelling out to Cargo and this can
+            // cause a non-trivial amount of time due to disk access
+            thread::spawn(move || {
+                let mut config = config.lock().unwrap();
+                if let Err(e) = config.infer_defaults(&current_project) {
+                    debug!(
+                        "Encountered an error while trying to infer config defaults: {:?}",
+                        e
+                    );
+                }
+            });
+        }
 
         if !init_options.omit_init_build {
             self.build_current_project(BuildPriority::Cargo, out);

src/actions/notifications.rs

@@ -11,11 +11,9 @@
 //! One-way notifications that the RLS receives from the client.
 
 use crate::actions::{FileWatch, InitActionContext, VersionOrdering};
-use crate::config::Config;
 use crate::Span;
 use log::{debug, trace, warn};
 use rls_vfs::{Change, VfsSpan};
-use serde::de::Error;
 use serde::Deserialize;
 use serde_json;
 use std::sync::atomic::Ordering;
@@ -158,16 +156,12 @@ impl BlockingNotificationAction for DidChangeConfiguration {
         out: O,
     ) -> Result<(), ()> {
         trace!("config change: {:?}", params.settings);
-        let config = params
-            .settings
-            .get("rust")
-            .ok_or_else(|| serde_json::Error::missing_field("rust"))
-            .and_then(Config::deserialize);
+        let settings = ChangeConfigSettings::deserialize(&params.settings);
 
-        let new_config = match config {
+        let new_config = match settings {
             Ok(mut value) => {
-                value.normalise();
-                value
+                value.rust.normalise();
+                value.rust
             }
             Err(err) => {
                 warn!(

src/config.rs

@@ -114,7 +114,7 @@ impl<T> AsRef<T> for Inferrable<T> {
 }
 
 /// RLS configuration options.
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize)]
 #[allow(missing_docs)]
 #[serde(default)]
 pub struct Config {

src/lsp_data.rs

@@ -21,6 +21,7 @@ use rls_span as span;
 use serde_derive::{Deserialize, Serialize};
 use url::Url;
 
+use crate::config;
 use crate::actions::hover;
 
 pub use languageserver_types::notification::Notification as LSPNotification;
@@ -256,23 +257,32 @@ impl RangeExt for Range {
     }
 }
 
+/// `DidChangeConfigurationParams.settings` payload reading the { rust: {...} } bit.
+#[derive(Debug, Deserialize)]
+pub struct ChangeConfigSettings {
+    pub rust: config::Config,
+}
+
 /* -----------------  JSON-RPC protocol types ----------------- */
 
 /// Supported initialization options that can be passed in the `initialize`
 /// request, under `initialization_options` key. These are specific to the RLS.
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct InitializationOptions {
     /// Should the build not be triggered immediately after receiving `initialize`
     pub omit_init_build: bool,
     pub cmd_run: bool,
+    /// `DidChangeConfigurationParams.settings` payload for upfront configuration.
+    pub settings: Option<ChangeConfigSettings>,
 }
 
 impl Default for InitializationOptions {
     fn default() -> Self {
         InitializationOptions {
             omit_init_build: false,
             cmd_run: false,
+            settings: None,
         }
     }
 }

src/server/mod.rs

@@ -98,10 +98,16 @@ impl BlockingRequestAction for InitializeRequest {
         let init_options: InitializationOptions = params
             .initialization_options
             .as_ref()
-            .and_then(|options| serde_json::from_value(options.to_owned()).ok())
+            .and_then(|options| {
+                let de = serde_json::from_value(options.to_owned());
+                if let Err(ref e) = de {
+                    warn!("initialization_options: {}", e);
+                }
+                de.ok()
+            })
             .unwrap_or_default();
 
-        trace!("init: {:?}", init_options);
+        trace!("init: {:?} -> {:?}", params.initialization_options, init_options);
 
         if ctx.inited().is_ok() {
             return Err(ResponseError::Message(
@@ -120,7 +126,7 @@ impl BlockingRequestAction for InitializeRequest {
         result.send(id, &out);
 
         let capabilities = lsp_data::ClientCapabilities::new(&params);
-        ctx.init(get_root_path(&params), &init_options, capabilities, &out)
+        ctx.init(get_root_path(&params), init_options, capabilities, &out)
             .unwrap();
 
         Ok(NoResponse)

src/test/harness.rs

@@ -95,16 +95,17 @@ impl Environment {
     crate fn mock_server(
         &mut self,
         messages: Vec<String>,
-    ) -> (ls_server::LsService<RecordOutput>, LsResultList) {
+    ) -> (ls_server::LsService<RecordOutput>, LsResultList, Arc<Mutex<Config>>) {
         let analysis = Arc::new(AnalysisHost::new(Target::Debug));
         let vfs = Arc::new(Vfs::new());
         let config = Arc::new(Mutex::new(self.config.take().unwrap()));
         let reader = Box::new(MockMsgReader::new(messages));
         let output = RecordOutput::new();
         let results = output.output.clone();
         (
-            ls_server::LsService::new(analysis, vfs, config, reader, output),
+            ls_server::LsService::new(analysis, vfs, Arc::clone(&config), reader, output),
             results,
+            config,
         )
     }
 }

src/test/lens.rs

@@ -6,7 +6,6 @@ use url::Url;
 
 use crate::{
     actions::requests,
-    lsp_data::InitializationOptions,
     server as ls_server,
     test::{
         harness::{compare_json, expect_message, expect_series, Environment, ExpectedMessage},
@@ -16,6 +15,8 @@ use crate::{
 
 #[test]
 fn test_lens_run() {
+    use serde_json::json;
+
     let mut env = Environment::new("lens_run");
 
     let source_file_path = Path::new("src").join("main.rs");
@@ -29,10 +30,7 @@ fn test_lens_run() {
         initialize_with_opts(
             0,
             root_path,
-            Some(InitializationOptions {
-                omit_init_build: false,
-                cmd_run: true,
-            }),
+            Some(json!({ "cmdRun": true })),
         ).to_string(),
         request::<requests::CodeLensRequest>(
             100,
@@ -42,7 +40,7 @@ fn test_lens_run() {
         ).to_string(),
     ];
 
-    let (mut server, results) = env.mock_server(messages);
+    let (mut server, results, ..) = env.mock_server(messages);
     // Initialize and build.
     assert_eq!(
         ls_server::LsService::handle_message(&mut server),