distributed compilation support for asm & preprocessed outputs

Fixes #2556

Author: AJIOB

Cargo.lock

@@ -122,6 +122,7 @@ rouille = { version = "3.6", optional = true, default-features = false, features
 ] }
 syslog = { version = "6", optional = true }
 version-compare = { version = "0.1.1", optional = true }
+enum-iterator = "2.3.0"
 
 [dev-dependencies]
 assert_cmd = "2.0.13"

Cargo.toml

@@ -38,6 +38,7 @@ use crate::server;
 use crate::util::{fmt_duration_as_secs, run_input_output};
 use crate::{counted_array, dist};
 use async_trait::async_trait;
+use enum_iterator::Sequence;
 use filetime::FileTime;
 use fs::File;
 use fs_err as fs;
@@ -212,7 +213,7 @@ pub enum CompilerKind {
     Rust,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Sequence)]
 pub enum Language {
     AssemblerToPreprocess,
     Assembler,
@@ -304,6 +305,17 @@ impl Language {
         )
     }
 
+    pub fn to_c_preprocessed_language(self) -> Option<Language> {
+        match self {
+            Language::AssemblerToPreprocess => Some(Language::Assembler),
+            Language::C => Some(Language::CPreprocessed),
+            Language::Cxx => Some(Language::CxxPreprocessed),
+            Language::ObjectiveC => Some(Language::ObjectiveCPreprocessed),
+            Language::ObjectiveCxx => Some(Language::ObjectiveCxxPreprocessed),
+            _ => None,
+        }
+    }
+
     /// Common implementation for GCC and Clang language argument mapping
     fn to_compiler_arg(self, cuda_arg: &'static str) -> Option<&'static str> {
         match self {
@@ -1856,13 +1868,29 @@ mod test {
     use crate::mock_command::*;
     use crate::test::mock_storage::MockStorage;
     use crate::test::utils::*;
+    use enum_iterator::all;
     use fs::File;
     use std::io::{Cursor, Write};
     use std::sync::Arc;
     use std::time::Duration;
     use test_case::test_case;
     use tokio::runtime::Runtime;
 
+    #[test]
+    fn test_c_preprocessing_consistent() {
+        for lang in all::<Language>() {
+            let maybe_processed = lang.to_c_preprocessed_language();
+
+            if let Some(processed) = maybe_processed {
+                assert!(!processed.needs_c_preprocessing(), "{:?} should not need preprocessing - it is a reasult of {:?} processing", processed, lang);
+            }
+
+            if !lang.needs_c_preprocessing() {
+                assert!(maybe_processed.is_none(), "{:?} should not be processed, but it is produce the {:?} as a C preprocessing result", lang, maybe_processed.unwrap());
+            }
+        }
+    }
+
     #[test]
     fn test_detect_compiler_kind_gcc() {
         let f = TestFixture::new();

src/compiler/compiler.rs

@@ -909,10 +909,13 @@ where
             let mut language: Option<String> =
                 language_to_arg(parsed_args.language).map(|lang| lang.into());
             if !rewrite_includes_only {
-                match parsed_args.language {
-                    Language::C => language = Some("cpp-output".into()),
-                    Language::GenericHeader | Language::CHeader | Language::CxxHeader => {}
-                    _ => language.as_mut()?.push_str("-cpp-output"),
+                if matches!(parsed_args.language, Language::GenericHeader | Language::CHeader | Language::CxxHeader) {
+                    // Nothing to do
+                }
+                else if let Some(processed_lang) = parsed_args.language.to_c_preprocessed_language() {
+                    language = Some(language_to_arg(processed_lang)?.into());
+                } else if parsed_args.language.needs_c_preprocessing() {
+                    language.as_mut()?.push_str("-cpp-output");
                 }
             }