distributed compilation support for asm & preprocessor outputs

Fixes #2556

Author: AJIOB

Cargo.lock

@@ -42,6 +42,7 @@ chrono = "0.4"
 clap = { version = "4.5.13", features = ["derive", "env", "wrap_help"] }
 directories = "6.0"
 encoding_rs = "0.8"
+enum-iterator = "2.3.0"
 env_logger = "0.11"
 filetime = "0.2"
 flate2 = { version = "1.0", optional = true, default-features = false, features = [

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,
@@ -305,6 +306,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 {
@@ -1859,13 +1871,39 @@ 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 result 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

@@ -911,12 +911,17 @@ where
             // https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Overall-Options.html
             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 rewrite_includes_only
+                || 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");
             }
 
             let mut arguments: Vec<String> = vec![];