fix(lsp): escape unescaped Unicode and spaces in file URIs from any server

lsp-types rejects a URI with raw non-ASCII characters or spaces, so one such
file URI made the whole response fail to deserialize ("data did not match any
variant of untagged enum DocumentChanges"). Java servers build some URIs with
java.net.URI.toString(), which keeps non-ASCII characters, e.g. jdtls in
Introduce Variable's edit for a project under a Chinese path. The csharp-ls
normalisation now applies to file: URIs from every server, in responses,
publishDiagnostics and workspace/applyEdit, including WorkspaceEdit.changes keys.

crates/ide-lsp/src/handler.rs

@@ -223,6 +223,8 @@ impl ClientHandler {
         if self.server.running_gen(self.generation).is_some_and(|run| !run.caps.read().restriction.diagnostics()) {
             return;
         }
+        let mut params = params;
+        crate::virtual_doc::normalize_uris(&mut params);
         let params: lsp::PublishDiagnosticsParams = match serde_json::from_value(params) {
             Ok(p) => p,
             Err(e) => {
@@ -322,11 +324,13 @@ impl ClientHandler {
     }
 
     fn apply_edit(&self, mgr: &LspManager, params: Value) -> Result<Value, (i64, String)> {
-        let edit: lsp::WorkspaceEdit = params
-            .get("edit")
-            .cloned()
-            .ok_or_else(|| (codes::INVALID_PARAMS, "missing edit".to_owned()))
-            .and_then(|e| serde_json::from_value(e).map_err(|e| (codes::INVALID_PARAMS, e.to_string())))?;
+        let edit: lsp::WorkspaceEdit =
+            params.get("edit").cloned().ok_or_else(|| (codes::INVALID_PARAMS, "missing edit".to_owned())).and_then(
+                |mut e| {
+                    crate::virtual_doc::normalize_uris(&mut e);
+                    serde_json::from_value(e).map_err(|e| (codes::INVALID_PARAMS, e.to_string()))
+                },
+            )?;
         // Convert before calling the hook: it re-enters document sync.
         let edit = convert::workspace_edit(&mgr.conv(self.encoding()), edit);
         let applied = match mgr.apply_edit_hook() {

crates/ide-lsp/src/lib.rs

@@ -1440,13 +1440,9 @@ impl LspManager {
         let params = serde_json::to_value(params).map_err(|e| IdeError::internal(e.to_string()))?;
         let stamp = self.injected_request_stamp(&params);
         let fut = async {
-            if t.server.name == "csharp-ls" {
-                let mut value = t.run.peer.request::<Value, Value>(method, params, cancel.cloned()).await?;
-                virtual_doc::normalize_csharp_uris(&mut value);
-                serde_json::from_value(value).map_err(|e| RpcError::Protocol(format!("{method}: {e}")))
-            } else {
-                t.run.peer.request::<Value, R>(method, params, cancel.cloned()).await
-            }
+            let mut value = t.run.peer.request::<Value, Value>(method, params, cancel.cloned()).await?;
+            virtual_doc::normalize_uris(&mut value);
+            serde_json::from_value(value).map_err(|e| RpcError::Protocol(format!("{method}: {e}")))
         };
         let result = match tokio::time::timeout(timeout, fut).await {
             Ok(r) => r.map_err(|e| rpc_err(&t.server.name, method, e)),

crates/ide-lsp/src/virtual_doc.rs

@@ -18,23 +18,36 @@ const URI_ESCAPES: &AsciiSet = &CONTROLS
     .add(b'|')
     .add(b'}');
 
-/// csharp-ls uses .NET Uri.ToString(), which can leave spaces and Unicode unescaped.
-/// Normalize only document URI fields, before lsp-types' strict URI deserialization.
-pub(crate) fn normalize_csharp_uris(value: &mut serde_json::Value) {
+/// Servers can leave spaces and Unicode unescaped in document URIs: csharp-ls uses .NET
+/// `Uri.ToString()`, and Java servers build some URIs with `java.net.URI.toString()` (which keeps
+/// non-ASCII characters), e.g. jdtls in a refactoring's edit for a project under a Chinese path.
+/// Escape them in document URI fields (and `WorkspaceEdit.changes` keys) before lsp-types' strict
+/// URI deserialization, which otherwise rejects the whole response.
+pub(crate) fn normalize_uris(value: &mut serde_json::Value) {
     match value {
-        serde_json::Value::Array(values) => values.iter_mut().for_each(normalize_csharp_uris),
+        serde_json::Value::Array(values) => values.iter_mut().for_each(normalize_uris),
         serde_json::Value::Object(fields) => {
-            for (key, value) in fields {
+            for (key, value) in fields.iter_mut() {
                 // Opaque payloads must survive resolve/execute round trips unchanged.
                 if matches!(key.as_str(), "data" | "arguments") {
                     continue;
                 }
-                if matches!(key.as_str(), "uri" | "targetUri")
-                    && let Some(uri) = value.as_str().filter(|s| s.starts_with("csharp:"))
+                if matches!(key.as_str(), "uri" | "targetUri" | "oldUri" | "newUri")
+                    && let Some(uri) = value.as_str().and_then(escaped_uri)
                 {
-                    *value = utf8_percent_encode(uri, URI_ESCAPES).to_string().into();
+                    *value = uri.into();
+                } else if key == "changes"
+                    && let serde_json::Value::Object(changes) = value
+                {
+                    *changes = std::mem::take(changes)
+                        .into_iter()
+                        .map(|(uri, mut edits)| {
+                            normalize_uris(&mut edits);
+                            (escaped_uri(&uri).unwrap_or(uri), edits)
+                        })
+                        .collect();
                 } else {
-                    normalize_csharp_uris(value);
+                    normalize_uris(value);
                 }
             }
         }
@@ -42,6 +55,16 @@ pub(crate) fn normalize_csharp_uris(value: &mut serde_json::Value) {
     }
 }
 
+/// `uri` with the characters a URI can't hold escaped; `None` when nothing changes or it is
+/// not a document URI this applies to (other schemes are passed back to servers as given).
+fn escaped_uri(uri: &str) -> Option<String> {
+    if !(uri.starts_with("file:") || uri.starts_with("csharp:")) {
+        return None;
+    }
+    let escaped = utf8_percent_encode(uri, URI_ESCAPES).to_string();
+    (escaped != uri).then_some(escaped)
+}
+
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct CSharpMetadata {
@@ -202,7 +225,7 @@ mod tests {
             { "data": { "uri": uri }, "command": { "arguments": [{ "targetUri": uri }] } }
         ]);
         let original = response.clone();
-        normalize_csharp_uris(&mut response);
+        normalize_uris(&mut response);
         assert_eq!(response[0]["uri"], encoded);
         assert_eq!(response[0]["source"], uri);
         assert_eq!(response[1]["location"]["targetUri"], encoded);
@@ -210,6 +233,31 @@ mod tests {
         assert!(encoded.parse::<lsp_types::Uri>().is_ok());
     }
 
+    /// #3089: jdtls's Introduce Variable edit for a project under a Chinese path names the file
+    /// with the characters unescaped, and the resolved code action failed to deserialize.
+    #[test]
+    fn file_uris_with_unicode_and_spaces_deserialize_in_workspace_edits() {
+        let uri = "file:///C:/项目/my app/src/A.java";
+        let encoded = "file:///C:/%E9%A1%B9%E7%9B%AE/my%20app/src/A.java";
+        let edit = serde_json::json!([{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 0 } }, "newText": "x" }]);
+        let mut action = serde_json::json!({
+            "title": "Extract to local variable",
+            "edit": {
+                "documentChanges": [{ "textDocument": { "uri": uri, "version": 3 }, "edits": edit }],
+                "changes": { (uri): edit },
+            },
+            "data": { "uri": uri },
+        });
+        assert!(serde_json::from_value::<lsp_types::CodeAction>(action.clone()).is_err());
+        normalize_uris(&mut action);
+        let action: lsp_types::CodeAction = serde_json::from_value(action.clone()).unwrap();
+        let edit = action.edit.unwrap();
+        let Some(lsp_types::DocumentChanges::Edits(edits)) = edit.document_changes else { panic!() };
+        assert_eq!(edits[0].text_document.uri.as_str(), encoded);
+        assert_eq!(edit.changes.unwrap().keys().next().unwrap().as_str(), encoded);
+        assert_eq!(action.data.unwrap()["uri"], uri, "opaque data is passed back unchanged");
+    }
+
     #[test]
     fn jdt_titles() {
         assert_eq!(title(JDT, true), "SpringApplication.class");