Auto merge of #1298 - lijinpei:kebab-case, r=alexheretic

implement kebab case config support

This pr tries to implement half of what's said in #1153 (reporting unused configs can be implemented in a separate pr). It introduces a new dependency on [heck](https://crates.io/crates/heck) for case conversion, add a little bit tweak to [struct Config in lsp_data.rs](https://github.com/lijinpei/rls/commit/cbeb77b03759cefe9091e4587aabb249adaff6c9#diff-5c71a9e04104a098c5f6e6f6af6a2ff5R249) so that Config'keys can be deserialized ignoring case(It basically first deserializes to a serde_json::Value, convert the case, then deserializes to the real struct Config), and add a few test-cases.

Author: bors

Cargo.lock

@@ -52,6 +52,7 @@ regex = "1"
 ordslice = "0.3"
 crossbeam-channel = "0.3"
 toml = "0.4"
+heck = "0.3"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.
 # See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`

Cargo.toml

@@ -306,7 +306,7 @@ impl InitActionContext {
         let needs_inference = {
             let mut config = self.config.lock().unwrap();
 
-            if let Some(init_config) = init_options.settings.map(|s| s.rust) {
+            if let Some(init_config) = init_options.settings.map(|s| s.rust.0) {
                 config.update(init_config);
             }
             config.needs_inference()

src/actions/mod.rs

@@ -150,17 +150,18 @@ impl BlockingNotificationAction for Cancel {
 
 impl BlockingNotificationAction for DidChangeConfiguration {
     fn handle<O: Output>(
-        params: DidChangeConfigurationParams,
+        mut params: DidChangeConfigurationParams,
         ctx: &mut InitActionContext,
         out: O,
     ) -> Result<(), ()> {
         trace!("config change: {:?}", params.settings);
+	params.settings = crate::lsp_data::json_key_to_snake_case(params.settings);
         let settings = ChangeConfigSettings::deserialize(&params.settings);
 
         let new_config = match settings {
             Ok(mut value) => {
-                value.rust.normalise();
-                value.rust
+                value.rust.0.normalise();
+                value.rust.0
             }
             Err(err) => {
                 warn!(

src/actions/notifications.rs

@@ -246,10 +246,31 @@ impl RangeExt for Range {
     }
 }
 
+pub struct Config(pub config::Config);
+
+impl<'de> serde::Deserialize<'de> for Config {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de> {
+            use serde::de::Error;
+            let val = json_key_to_snake_case(serde_json::Value::deserialize(deserializer)?);
+            match serde_json::from_value(val) {
+                Ok(config) => Ok(Config(config)),
+                _ => Err(D::Error::custom("unable to deserialize Config")),
+            }
+        }
+}
+
+impl fmt::Debug for Config {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
 /// `DidChangeConfigurationParams.settings` payload reading the { rust: {...} } bit.
 #[derive(Debug, Deserialize)]
 pub struct ChangeConfigSettings {
-    pub rust: config::Config,
+    pub rust: Config,
 }
 
 /* -----------------  JSON-RPC protocol types ----------------- */
@@ -395,3 +416,29 @@ pub struct ProgressParams {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub done: Option<bool>,
 }
+
+pub fn json_key_to_snake_case(mut val: serde_json::Value) -> serde_json::Value {
+    fn helper(val: &mut serde_json::Value) -> &mut serde_json::Value {
+        use heck::SnakeCase;
+        use serde_json::Value;
+        match val {
+            Value::Object(map) => {
+                let mut map1 = serde_json::map::Map::<String, Value>::with_capacity(map.len());
+                for kv in map.into_iter() {
+                    match map1.insert(kv.0.as_str().to_snake_case(), kv.1.clone()) {
+                        Some(val) => {
+                            log::error!("Multiple different case uses of `{}` config with value {} and value {}", kv.0, val, kv.1);
+                        }
+                        _ => (),
+                    }
+                }
+                std::mem::replace(map, map1);
+            }
+            _ => (),
+        }
+        val
+    }
+    helper(&mut val);
+    val
+}
+

src/lsp_data.rs

@@ -1105,8 +1105,35 @@ fn test_omit_init_build() {
     );
 }
 
-#[test]
-fn test_init_with_configuration() {
+pub trait ConvertStringCase {
+    fn convert_string_case(s: &str) -> String;
+}
+
+struct CamelCaseConverter;
+impl ConvertStringCase for CamelCaseConverter {
+    fn convert_string_case<'a>(s:&'a str) -> String {
+      use heck::CamelCase;
+      s.to_camel_case().to_string()
+    }
+}
+
+struct KebabCaseConverter;
+impl ConvertStringCase for KebabCaseConverter {
+    fn convert_string_case<'a>(s:&'a str) -> String {
+      use heck::KebabCase;
+      s.to_kebab_case().to_string()
+    }
+}
+
+struct SnakeCaseConverter;
+impl ConvertStringCase for SnakeCaseConverter {
+    fn convert_string_case<'a>(s:&'a str) -> String {
+      use heck::SnakeCase;
+      s.to_snake_case().to_string()
+    }
+}
+
+fn test_init_impl<T:ConvertStringCase>() {
     use serde_json::json;
 
     let mut env = Environment::generate_from_fixture("common");
@@ -1116,8 +1143,8 @@ fn test_init_with_configuration() {
     let init_options = json!({
         "settings": {
             "rust": {
-                "features": ["some_feature"],
-                "all_targets": false
+                T::convert_string_case("features"): ["some_feature"],
+                T::convert_string_case("all_targets"): false
             }
         }
     });
@@ -1145,6 +1172,21 @@ fn test_init_with_configuration() {
     assert_eq!(config.lock().unwrap().all_targets, false);
 }
 
+#[test]
+fn test_init_with_configuration_camel_case() {
+    test_init_impl::<CamelCaseConverter>();
+}
+
+#[test]
+fn test_init_with_configuration_kebab_case() {
+    test_init_impl::<KebabCaseConverter>();
+}
+
+#[test]
+fn test_init_with_configuration_snake_case() {
+    test_init_impl::<SnakeCaseConverter>();
+}
+
 #[test]
 fn test_parse_error_on_malformed_input() {
     let _ = env_logger::try_init();