Merge pull request #635 from alexcrichton/update-cargo

Update cargo

Author: nrc

Cargo.lock

@@ -12,6 +12,7 @@ build = "build.rs"
 [dependencies]
 cargo = { git = "https://github.com/rust-lang/cargo" }
 env_logger = "0.4"
+failure = "0.1.1"
 jsonrpc-core = "7.0.1"
 languageserver-types = "0.16"
 lazy_static = "0.2"

Cargo.toml

@@ -56,19 +56,19 @@ impl PostBuildHandler {
  self.notifier.notify_begin();
 
  match result {
- BuildResult::Success(messages, new_analysis) => {
+ BuildResult::Success(cwd, messages, new_analysis) => {
  thread::spawn(move || {
  trace!("build - Success");
 
  // Emit appropriate diagnostics using the ones from build.
- self.handle_messages(messages);
+ self.handle_messages(&cwd, messages);
 
  // Reload the analysis data.
  debug!("reload analysis: {:?}", self.project_path);
  if new_analysis.is_empty() {
- self.reload_analysis_from_disk();
+ self.reload_analysis_from_disk(&cwd);
  } else {
- self.reload_analysis_from_memory(new_analysis);
+ self.reload_analysis_from_memory(&cwd, new_analysis);
  }
 
  // Wake up any threads blocked on this analysis.
@@ -90,7 +90,7 @@ impl PostBuildHandler {
  }
  }
 
- fn handle_messages(&self, messages: Vec<String>) {
+ fn handle_messages(&self, cwd: &Path, messages: Vec<String>) {
  // These notifications will include empty sets of errors for files
  // which had errors, but now don't. This instructs the IDE to clear
  // errors for those files.
@@ -101,8 +101,6 @@ impl PostBuildHandler {
  v.clear();
  }
 
- let cwd = ::std::env::current_dir().unwrap();
-
  for msg in &messages {
  if let Some(FileDiagnostic {
  file_path,
@@ -119,8 +117,7 @@ impl PostBuildHandler {
  self.emit_notifications(&results);
  }
 
- fn reload_analysis_from_disk(&self) {
- let cwd = ::std::env::current_dir().unwrap();
+ fn reload_analysis_from_disk(&self, cwd: &Path) {
  if self.use_black_list {
  self.analysis
  .reload_with_blacklist(&self.project_path, &cwd, &CRATE_BLACKLIST)
@@ -130,8 +127,7 @@ impl PostBuildHandler {
  }
  }
 
- fn reload_analysis_from_memory(&self, analysis: Vec<Analysis>) {
- let cwd = ::std::env::current_dir().unwrap();
+ fn reload_analysis_from_memory(&self, cwd: &Path, analysis: Vec<Analysis>) {
  if self.use_black_list {
  self.analysis
  .reload_from_analysis(analysis, &self.project_path, &cwd, &CRATE_BLACKLIST)

src/actions/post_build.rs

@@ -25,7 +25,7 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::env;
 use std::ffi::OsString;
 use std::fs::{read_dir, remove_file};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -64,10 +64,10 @@ pub(super) fn cargo(internals: &Internals) -> BuildResult {
 
  match handle
  .join()
- .map_err(|_| "thread panicked".into())
+ .map_err(|_| format_err!("thread panicked"))
  .and_then(|res| res)
  {
- Ok(_) if workspace_mode => {
+ Ok(ref cwd) if workspace_mode => {
  let diagnostics = Arc::try_unwrap(diagnostics_clone)
  .unwrap()
  .into_inner()
@@ -76,9 +76,9 @@ pub(super) fn cargo(internals: &Internals) -> BuildResult {
  .unwrap()
  .into_inner()
  .unwrap();
- BuildResult::Success(diagnostics, analysis)
+ BuildResult::Success(cwd.clone(), diagnostics, analysis)
  }
- Ok(_) => BuildResult::Success(vec![], vec![]),
+ Ok(cwd) => BuildResult::Success(cwd, vec![], vec![]),
  Err(err) => {
  let stdout = String::from_utf8(out_clone.lock().unwrap().to_owned()).unwrap();
  info!("cargo failed\ncause: {}\nstdout: {}", err, stdout);
@@ -95,13 +95,15 @@ fn run_cargo(
  compiler_messages: Arc<Mutex<Vec<String>>>,
  analysis: Arc<Mutex<Vec<Analysis>>>,
  out: Arc<Mutex<Vec<u8>>>,
-) -> CargoResult<()> {
+) -> CargoResult<PathBuf> {
  // Lock early to guarantee synchronized access to env var for the scope of Cargo routine.
  // Additionally we need to pass inner lock to RlsExecutor, since it needs to hand it down
  // during exec() callback when calling linked compiler in parallel, for which we need to
  // guarantee consistent environment variables.
  let (lock_guard, inner_lock) = env_lock.lock();
 
+ let mut restore_env = Environment::push_with_lock(&HashMap::new(), None, lock_guard);
+
  let build_dir = {
  let mut compilation_cx = compilation_cx.lock().unwrap();
  // Since Cargo build routine will try to regenerate the unit dep graph,
@@ -123,7 +125,7 @@ fn run_cargo(
  let rls_config = rls_config.lock().unwrap();
 
  let target_dir = rls_config.target_dir.as_ref().map(|p| p as &Path);
- make_cargo_config(manifest_dir, target_dir, shell)
+ make_cargo_config(manifest_dir, target_dir, restore_env.get_old_cwd(), shell)
  };
 
  let ws = Workspace::new(&manifest_path, &config)?;
@@ -186,16 +188,14 @@ fn run_cargo(
  ..CompileOptions::default(&config, CompileMode::Check { test: false })
  };
 
- // Create a custom environment for running cargo, the environment is reset afterwards automatically
- let mut env: HashMap<String, Option<OsString>> = HashMap::new();
- env.insert("RUSTFLAGS".to_owned(), Some(rustflags.into()));
+ // Create a custom environment for running cargo, the environment is reset
+ // afterwards automatically
+ restore_env.push_var("RUSTFLAGS", &Some(rustflags.into()));
 
  if clear_env_rust_log {
- env.insert("RUST_LOG".to_owned(), None);
+ restore_env.push_var("RUST_LOG", &None);
  }
 
- let _restore_env = Environment::push_with_lock(&env, lock_guard);
-
  let exec = RlsExecutor::new(
  &ws,
  compilation_cx.clone(),
@@ -213,7 +213,9 @@ fn run_cargo(
  compilation_cx.lock().unwrap().build_plan
  );
 
- Ok(())
+ Ok(compilation_cx.lock().unwrap().cwd.clone().unwrap_or_else(|| {
+ restore_env.get_old_cwd().to_path_buf()
+ }))
 }
 
 struct RlsExecutor {
@@ -475,11 +477,12 @@ impl Executor for RlsExecutor {
  &self.vfs,
  &args,
  &envs,
+ cargo_cmd.get_cwd(),
  &build_dir,
  self.config.clone(),
  env_lock,
  ) {
- BuildResult::Success(mut messages, mut analysis) => {
+ BuildResult::Success(_, mut messages, mut analysis) => {
  self.compiler_messages.lock().unwrap().append(&mut messages);
  self.analysis.lock().unwrap().append(&mut analysis);
  }
@@ -493,6 +496,7 @@ impl Executor for RlsExecutor {
  let mut compilation_cx = self.compilation_cx.lock().unwrap();
  compilation_cx.args = args;
  compilation_cx.envs = envs;
+ compilation_cx.cwd = cargo_cmd.get_cwd().map(|p| p.to_path_buf());
 
  Ok(())
  }
@@ -596,13 +600,13 @@ fn prepare_cargo_rustflags(config: &Config) -> String {
 
 /// Construct a cargo configuration for the given build and target directories
 /// and shell.
-pub fn make_cargo_config(build_dir: &Path, target_dir: Option<&Path>, shell: Shell) -> CargoConfig {
+pub fn make_cargo_config(build_dir: &Path,
+ target_dir: Option<&Path>,
+ cwd: &Path,
+ shell: Shell) -> CargoConfig {
  let config = CargoConfig::new(
  shell,
- // This is Cargo's cwd. We're using the actual cwd,
- // because Cargo will generate relative paths based
- // on this to source files it wants to compile
- env::current_dir().unwrap(),
+ cwd.to_path_buf(),
  homedir(&build_dir).unwrap(),
  );
 

src/build/cargo.rs

@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::collections::HashMap;
 use std::env;
 use std::ffi::OsString;
-use std::collections::HashMap;
+use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex, MutexGuard};
 
 // Ensures we don't race on the env vars. This is only also important in tests,
@@ -23,19 +24,26 @@ lazy_static! {
 /// Requires supplying an external lock guard to guarantee env var consistency across multiple threads.
 pub struct Environment<'a> {
  old_vars: HashMap<String, Option<OsString>>,
+ old_cwd: PathBuf,
  _guard: MutexGuard<'a, ()>,
 }
 
 impl<'a> Environment<'a> {
  pub fn push_with_lock(
  envs: &HashMap<String, Option<OsString>>,
+ cwd: Option<&Path>,
  lock: MutexGuard<'a, ()>,
  ) -> Environment<'a> {
  let mut result = Environment {
  old_vars: HashMap::new(),
+ old_cwd: env::current_dir().expect("failed to read cwd"),
  _guard: lock,
  };
 
+ if let Some(cwd) = cwd {
+ env::set_current_dir(cwd).expect("failed to change cwd");
+ }
+
  for (k, v) in envs {
  result.push_var(k, v);
  }
@@ -49,10 +57,15 @@ impl<'a> Environment<'a> {
  None => env::remove_var(key),
  }
  }
+
+ pub fn get_old_cwd(&self) -> &Path {
+ &self.old_cwd
+ }
 }
 
 impl<'a> Drop for Environment<'a> {
  fn drop(&mut self) {
+ drop(env::set_current_dir(&self.old_cwd));
  for (k, v) in &self.old_vars {
  match *v {
  Some(ref v) => env::set_var(k, v),