Merge pull request #495 from Xanewok/utf8-diagnostics

Preserve UTF-8 file path in the resulting compiler diagnostics

Author: nrc

src/actions/post_build.rs

@@ -236,25 +236,23 @@ fn emit_notifications<O: Output>(
 ) {
     let cwd = ::std::env::current_dir().unwrap();
 
-    build_results
-        .iter()
-        .for_each(|(path, diagnostics)| {
-            let params = PublishDiagnosticsParams {
-                uri: Url::from_file_path(cwd.join(path)).unwrap(),
-                diagnostics: diagnostics.iter()
-                    .filter_map(|&(ref d, _)| {
-                        if show_warnings || d.severity != Some(DiagnosticSeverity::Warning) {
-                            Some(d.clone())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect(),
-            };
+    for (path, diagnostics) in build_results {
+        let params = PublishDiagnosticsParams {
+            uri: Url::from_file_path(cwd.join(path)).unwrap(),
+            diagnostics: diagnostics.iter()
+                .filter_map(|&(ref d, _)| {
+                    if show_warnings || d.severity != Some(DiagnosticSeverity::Warning) {
+                        Some(d.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+        };
 
-            out.notify(NotificationMessage::new(
-                ls_types::NOTIFICATION__PublishDiagnostics,
-                Some(params),
-            ));
-        })
+        out.notify(NotificationMessage::new(
+            ls_types::NOTIFICATION__PublishDiagnostics,
+            Some(params),
+        ));
+    }
 }

src/build/rustc.rs

@@ -74,16 +74,15 @@ pub fn rustc(vfs: &Vfs, args: &[String], envs: &HashMap<String, Option<OsString>
 
     // FIXME(#25) given that we are running the compiler directly, there is no need
     // to serialise the error messages - we should pass them in memory.
-    let stderr_json_msg = convert_message_to_json_strings(Arc::try_unwrap(err_buf)
-        .unwrap()
-        .into_inner()
-        .unwrap());
+    let err_buf = Arc::try_unwrap(err_buf).unwrap().into_inner().unwrap();
+    let err_buf = String::from_utf8(err_buf).unwrap();
+    let stderr_json_msgs: Vec<_> = err_buf.lines().map(String::from).collect();
 
     let analysis = analysis.lock().unwrap().clone();
     let analysis = analysis.map(|analysis| vec![analysis]).unwrap_or(vec![]);
     match exit_code {
-        Ok(0) => BuildResult::Success(stderr_json_msg, analysis),
-        _ => BuildResult::Failure(stderr_json_msg, analysis),
+        Ok(0) => BuildResult::Success(stderr_json_msgs, analysis),
+        _ => BuildResult::Failure(stderr_json_msgs, analysis),
     }
 }
 
@@ -181,39 +180,6 @@ impl<'a> CompilerCalls<'a> for RlsRustcCalls {
     }
 }
 
-pub fn convert_message_to_json_strings(input: Vec<u8>) -> Vec<String> {
-    let mut output = vec![];
-
-    // FIXME: this is *so gross*  Trying to work around cargo not supporting json messages
-    let it = input.into_iter();
-
-    let mut read_iter = it.skip_while(|&x| x != b'{');
-
-    let mut _msg = String::new();
-    loop {
-        match read_iter.next() {
-            Some(b'\n') => {
-                output.push(_msg);
-                _msg = String::new();
-                while let Some(res) = read_iter.next() {
-                    if res == b'{' {
-                        _msg.push('{');
-                        break;
-                    }
-                }
-            }
-            Some(x) => {
-                _msg.push(x as char);
-            }
-            None => {
-                break;
-            }
-        }
-    }
-
-    output
-}
-
 /// Tries to read a file from a list of replacements, and if the file is not
 /// there, then reads it from disk, by delegating to `RealFileLoader`.
 struct ReplacedFileLoader {

src/test/mod.rs

@@ -670,3 +670,26 @@ fn test_find_impls() {
     //         .expect_contains(r#""range":{"start":{"line":19,"character":12},"end":{"line":19,"character":15}}"#)
     // ]);
 }
+
+#[test]
+fn test_handle_utf8_directory() {
+    let (cache, _tc) = init_env("unicødë");
+
+    let root_path = cache.abs_path(Path::new("."));
+    let root_url = Url::from_directory_path(&root_path).unwrap();
+    let messages = vec![
+        initialize(0, root_path.as_os_str().to_str().map(|x| x.to_owned())).to_string()
+    ];
+
+    let (mut server, results) = mock_server(messages);
+    // Initialise and build.
+    assert_eq!(ls_server::LsService::handle_message(&mut server),
+               ls_server::ServerStateChange::Continue);
+    expect_messages(results.clone(), &[ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
+                                       ExpectedMessage::new(None).expect_contains("beginBuild"),
+                                       ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
+                                       ExpectedMessage::new(None)
+                                           .expect_contains(root_url.path())
+                                           .expect_contains("struct is never used: `Unused`"),
+                                       ExpectedMessage::new(None).expect_contains("diagnosticsEnd")]);
+}

test_data/unicødë/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "unicødë"
+version = "0.1.0"
+authors = ["Igor Matuszewski <[email protected]>"]
+
+[dependencies]

test_data/unicødë/Cargo.toml

@@ -0,0 +1,9 @@
+struct Unused {}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}