Rewrite .d files with correct paths after receiving them

Author: aidanhs

src/commands.rs

@@ -646,7 +646,7 @@ pub fn run_command(cmd: Command) -> Result<i32> {
         }
         #[cfg(not(feature = "dist-client"))]
         Command::PackageToolchain(_executable, _out) => {
-            bail!("Toolchain packaging not compiled in")
+            bail!("Toolchain packaging not compiled in, please rebuild with the dist-client feature")
         }
         Command::Compile { exe, cmdline, cwd, env_vars } => {
             trace!("Command::Compile {{ {:?}, {:?}, {:?} }}", exe, cmdline, cwd);

src/compiler/args.rs

@@ -146,6 +146,7 @@ impl<T: ArgumentValue> Argument<T> {
     }
 
     /// Transforms a parsed argument into an iterator over strings, with transformed paths.
+    #[cfg(feature = "dist-client")]
     pub fn iter_strings<F: FnMut(&Path) -> Option<String>>(&self, path_transformer: F) -> IterStrings<T, F> {
         IterStrings {
             arg: self,
@@ -206,12 +207,14 @@ impl<'a, T: ArgumentValue> Iterator for Iter<'a, T> {
     }
 }
 
+#[cfg(feature = "dist-client")]
 pub struct IterStrings<'a, T: 'a, F> {
     arg: &'a Argument<T>,
     emitted: usize,
     path_transformer: F,
 }
 
+#[cfg(feature = "dist-client")]
 impl<'a, T: ArgumentValue, F: FnMut(&Path) -> Option<String>> Iterator for IterStrings<'a, T, F> {
     type Item = ArgToStringResult;
 

src/compiler/c.rs

@@ -14,6 +14,8 @@
 
 use compiler::{Cacheable, ColorMode, Compiler, CompilerArguments, CompileCommand, CompilerHasher, CompilerKind,
                Compilation, HashResult};
+#[cfg(feature = "dist-client")]
+use compiler::{NoopOutputsRewriter, OutputsRewriter};
 use dist;
 #[cfg(feature = "dist-client")]
 use dist::pkg;
@@ -307,14 +309,15 @@ impl<I: CCompilerImpl> Compilation for CCompilation<I> {
     }
 
     #[cfg(feature = "dist-client")]
-    fn into_dist_packagers(self: Box<Self>, path_transformer: dist::PathTransformer) -> Result<(Box<pkg::InputsPackager>, Box<pkg::ToolchainPackager>)> {
+    fn into_dist_packagers(self: Box<Self>, path_transformer: dist::PathTransformer) -> Result<(Box<pkg::InputsPackager>, Box<pkg::ToolchainPackager>, Box<OutputsRewriter>)> {
         let CCompilation { parsed_args, cwd, preprocessed_input, executable, .. } = *{self};
         trace!("Dist inputs: {:?}", parsed_args.input);
 
         let input_path = cwd.join(&parsed_args.input);
         let inputs_packager = Box::new(CInputsPackager { input_path, preprocessed_input, path_transformer });
         let toolchain_packager = Box::new(CToolchainPackager { executable });
-        Ok((inputs_packager, toolchain_packager))
+        let outputs_rewriter = Box::new(NoopOutputsRewriter);
+        Ok((inputs_packager, toolchain_packager, outputs_rewriter))
     }
 
     fn outputs<'a>(&'a self) -> Box<Iterator<Item=(&'a str, &'a Path)> + 'a>

src/compiler/compiler.rs

@@ -362,7 +362,7 @@ fn dist_or_local_compile<T>(dist_client: Arc<dist::Client>,
             compilation.into_dist_packagers(path_transformer)
                 .map(|packagers| (dist_compile_cmd, packagers, dist_output_paths))
         })
-        .and_then(move |(mut dist_compile_cmd, (inputs_packager, toolchain_packager), dist_output_paths)| {
+        .and_then(move |(mut dist_compile_cmd, (inputs_packager, toolchain_packager, outputs_rewriter), dist_output_paths)| {
             debug!("[{}]: Identifying dist toolchain for {:?}", compile_out_pretty2, local_executable);
             // TODO: put on a thread
             let (dist_toolchain, maybe_dist_compile_executable) =
@@ -404,12 +404,16 @@ fn dist_or_local_compile<T>(dist_client: Arc<dist::Client>,
                         dist::RunJobResult::JobNotFound => panic!(),
                     };
                     info!("fetched {:?}", jc.outputs.iter().map(|&(ref p, ref bs)| (p, bs.lens().to_string())).collect::<Vec<_>>());
+                    let mut output_paths = vec![];
                     for (path, output_data) in jc.outputs {
                         let len = output_data.lens().actual;
-                        let mut file = File::create(path_transformer.to_local(&path)).unwrap();
+                        let local_path = path_transformer.to_local(&path);
+                        let mut file = File::create(&local_path).unwrap();
                         let count = io::copy(&mut output_data.into_reader(), &mut file).unwrap();
                         assert!(count == len);
+                        output_paths.push((path, local_path))
                     }
+                    outputs_rewriter.handle_outputs(&path_transformer, output_paths).unwrap();
                     jc.output.into()
                 })
             )
@@ -439,7 +443,7 @@ pub trait Compilation {
     /// Create a function that will create the inputs used to perform a distributed compilation
     #[cfg(feature = "dist-client")]
     fn into_dist_packagers(self: Box<Self>, _path_transformer: dist::PathTransformer)
-                           -> Result<(Box<pkg::InputsPackager>, Box<pkg::ToolchainPackager>)> {
+                           -> Result<(Box<pkg::InputsPackager>, Box<pkg::ToolchainPackager>, Box<OutputsRewriter>)> {
 
         bail!("distributed compilation not implemented")
     }
@@ -451,6 +455,22 @@ pub trait Compilation {
     fn outputs<'a>(&'a self) -> Box<Iterator<Item=(&'a str, &'a Path)> + 'a>;
 }
 
+#[cfg(feature = "dist-client")]
+pub trait OutputsRewriter {
+    fn handle_outputs(self: Box<Self>, path_transformer: &dist::PathTransformer, output_paths: Vec<(String, PathBuf)>)
+                      -> Result<()>;
+}
+
+#[cfg(feature = "dist-client")]
+pub struct NoopOutputsRewriter;
+#[cfg(feature = "dist-client")]
+impl OutputsRewriter for NoopOutputsRewriter {
+    fn handle_outputs(self: Box<Self>, _path_transformer: &dist::PathTransformer, _output_paths: Vec<(String, PathBuf)>)
+                      -> Result<()> {
+        Ok(())
+    }
+}
+
 /// Result of generating a hash from a compiler command.
 pub struct HashResult {
     /// The hash key of the inputs.

src/compiler/gcc.rs

@@ -402,6 +402,9 @@ pub fn generate_compile_commands(path_transformer: &mut dist::PathTransformer,
                                 env_vars: &[(OsString, OsString)])
                                 -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)>
 {
+    #[cfg(not(feature = "dist-client"))]
+    let _ = path_transformer;
+
     trace!("compile");
 
     let out_file = match parsed_args.outputs.get("obj") {
@@ -434,6 +437,9 @@ pub fn generate_compile_commands(path_transformer: &mut dist::PathTransformer,
         cwd: cwd.to_owned(),
     };
 
+    #[cfg(not(feature = "dist-client"))]
+    let dist_command = None;
+    #[cfg(feature = "dist-client")]
     let dist_command = (|| {
         // https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Overall-Options.html
         let language = match parsed_args.language {

src/compiler/msvc.rs

@@ -547,6 +547,9 @@ fn generate_compile_commands(path_transformer: &mut dist::PathTransformer,
                             env_vars: &[(OsString, OsString)])
                             -> Result<(CompileCommand, Option<dist::CompileCommand>, Cacheable)>
 {
+    #[cfg(not(feature = "dist-client"))]
+    let _ = path_transformer;
+
     trace!("compile");
     let out_file = match parsed_args.outputs.get("obj") {
         Some(obj) => obj,
@@ -585,6 +588,9 @@ fn generate_compile_commands(path_transformer: &mut dist::PathTransformer,
         cwd: cwd.to_owned(),
     };
 
+    #[cfg(not(feature = "dist-client"))]
+    let dist_command = None;
+    #[cfg(feature = "dist-client")]
     let dist_command = (|| {
         // http://releases.llvm.org/6.0.0/tools/clang/docs/UsersManual.html#clang-cl
         // TODO: Use /T... for language?