Tidy up the remaining implementation

Author: Xanewok

rls/src/build/ipc.rs

@@ -6,7 +6,6 @@ use std::time::Duration;
 use std::{env, fs};
 
 use jsonrpc_core::{ErrorCode, IoHandler};
-use rls_vfs::{FileContents, Vfs};
 
 use crate::build::plan::Crate;
 
@@ -33,7 +32,8 @@ impl Server {
     }
 }
 
-/// TODO: Document me
+/// Starts an IPC server in the background supporting both VFS requests and data
+/// callbacks used by rustc for the out-of-process compilation.
 pub fn start_with_all(
     changed_files: HashMap<PathBuf, String>,
     analysis: Arc<Mutex<Option<rls_data::Analysis>>>,
@@ -49,18 +49,6 @@ pub fn start_with_all(
     self::start_with_handler(io)
 }
 
-/// Spins up an IPC server in the background. Currently used for inter-process
-/// VFS, which is required for out-of-process rustc compilation.
-#[allow(dead_code)]
-pub fn start(vfs: Arc<Vfs>) -> Result<Server, ()> {
-    use rls_ipc::rpc::file_loader::Server as _;
-
-    let mut io = IoHandler::new();
-    io.extend_with(ArcVfs(vfs).to_delegate());
-
-    self::start_with_handler(io)
-}
-
 /// Spins up an IPC server in the background.
 pub fn start_with_handler(io: IoHandler) -> Result<Server, ()> {
     let endpoint_path = gen_endpoint_path();
@@ -104,37 +92,12 @@ fn rpc_error(msg: &str) -> Error {
     Error { code: ErrorCode::InternalError, message: msg.to_owned(), data: None }
 }
 
-struct ArcVfs(Arc<Vfs>);
-
-impl rpc::file_loader::Rpc for ArcVfs {
-    fn file_exists(&self, path: PathBuf) -> RpcResult<bool> {
-        // Copied from syntax::source_map::RealFileLoader
-        Ok(fs::metadata(path).is_ok())
-    }
-    fn abs_path(&self, path: PathBuf) -> RpcResult<Option<PathBuf>> {
-        // Copied from syntax::source_map::RealFileLoader
-        Ok(if path.is_absolute() {
-            Some(path.to_path_buf())
-        } else {
-            env::current_dir().ok().map(|cwd| cwd.join(path))
-        })
-    }
-    fn read_file(&self, path: PathBuf) -> RpcResult<String> {
-        self.0.load_file(&path).map_err(|e| rpc_error(&e.to_string())).and_then(|contents| {
-            match contents {
-                FileContents::Text(text) => Ok(text),
-                FileContents::Binary(..) => Err(rpc_error("File is binary")),
-            }
-        })
-    }
-}
-
 mod callbacks {
     use super::PathBuf;
     use super::{rpc, RpcResult};
     use super::{Arc, Mutex};
     use super::{HashMap, HashSet};
-    // use crate::build::plan::Crate;
+
     impl From<rls_ipc::rpc::Crate> for crate::build::plan::Crate {
         fn from(krate: rls_ipc::rpc::Crate) -> Self {
             Self {

rls/src/build/rustc.rs

@@ -69,12 +69,12 @@ pub(crate) fn rustc(
 
     let changed = vfs.get_cached_files();
 
-    let mut local_envs = envs.clone();
+    let mut envs = envs.clone();
 
     let clippy_preference = {
         let config = rls_config.lock().unwrap();
         if config.clear_env_rust_log {
-            local_envs.insert(String::from("RUST_LOG"), None);
+            envs.insert(String::from("RUST_LOG"), None);
         }
 
         config.clippy_preference
@@ -89,15 +89,16 @@ pub(crate) fn rustc(
         "RLS_OUT_OF_PROCESS",
     ) {
         #[cfg(feature = "ipc")]
-        Ok(..) => run_out_of_process(changed, &args, &local_envs, clippy_preference),
+        Ok(..) => run_out_of_process(changed.clone(), &args, &envs, clippy_preference)
+            .unwrap_or_else(|_| {
+                run_in_process(changed, &args, clippy_preference, lock_environment(&envs, cwd))
+            }),
         #[cfg(not(feature = "ipc"))]
         Ok(..) => {
-            log::warn!("Support for out-of-process compilation was not compiled. Re-build with 'ipc' feature enabled");
-            run_in_process(changed, &args, clippy_preference, lock_environment(&local_envs, cwd))
-        }
-        Err(..) => {
-            run_in_process(changed, &args, clippy_preference, lock_environment(&local_envs, cwd))
+            log::warn!("Support for out-of-process compilation was not compiled. Rebuild with 'ipc' feature enabled");
+            run_in_process(changed, &args, clippy_preference, lock_environment(&envs, cwd))
         }
+        Err(..) => run_in_process(changed, &args, clippy_preference, lock_environment(&envs, cwd)),
     };
 
     let stderr = String::from_utf8(stderr).unwrap();
@@ -128,13 +129,12 @@ fn run_out_of_process(
     args: &[String],
     envs: &HashMap<String, Option<OsString>>,
     clippy_preference: ClippyPreference,
-) -> CompilationResult {
+) -> Result<CompilationResult, ()> {
     let analysis = Arc::default();
     let input_files = Arc::default();
 
     let ipc_server =
-        super::ipc::start_with_all(changed, Arc::clone(&analysis), Arc::clone(&input_files));
-    let ipc_server = ipc_server.unwrap(); // TODO: Handle unwrap
+        super::ipc::start_with_all(changed, Arc::clone(&analysis), Arc::clone(&input_files))?;
 
     // Compiling out of process is only supported by our own shim
     let rustc_shim = env::current_exe()
@@ -143,13 +143,11 @@ fn run_out_of_process(
         .expect("Couldn't set executable for RLS rustc shim");
 
     let output = Command::new(rustc_shim)
-        // In case RLS is set as the rustc shim signal to `main_inner()` to call
-        // `rls_rustc::run()`.
         .env(crate::RUSTC_SHIM_ENV_VAR_NAME, "1")
         .env("RLS_IPC_ENDPOINT", ipc_server.endpoint())
         .env("RLS_CLIPPY_PREFERENCE", clippy_preference.to_string())
         .args(args.iter().skip(1))
-        .envs(envs.clone().into_iter().filter_map(|(k, v)| v.map(|v| (k, v))))
+        .envs(envs.iter().filter_map(|(k, v)| v.as_ref().map(|v| (k, v))))
         .output()
         .map_err(|_| ());
 
@@ -166,7 +164,7 @@ fn run_out_of_process(
     let analysis = unwrap_shared(analysis, "Other ref dropped by closed IPC server");
     // FIXME(#25): given that we are running the compiler directly, there is no need
     // to serialize the error messages -- we should pass them in memory.
-    CompilationResult { result, stderr, analysis, input_files }
+    Ok(CompilationResult { result, stderr, analysis, input_files })
 }
 
 fn run_in_process(