Fix #359: Support language-selection flags in is_flag_supported()

Changed flag validation from file-based to stdin-based compilation to
support language-selection flags like -xassembler-with-cpp. This also
improves flag validation by ensuring invalid flags are properly rejected.

- Use stdin compilation with explicit language for most flags
- For -x flags, let the flag determine the language
- Add -Werror=unknown-warning-option for clang to reject invalid -W flags
- Remove unused ensure_check_file() method
- Add regression test for assembly flags

Author: naoNao89

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Fix `is_flag_supported` to work with assembly-specific flags by using stdin compilation instead of file-based compilation ([#359](https://github.com/rust-lang/cc-rs/issues/359))
+
 ## [1.2.49](https://github.com/rust-lang/cc-rs/compare/cc-v1.2.48...cc-v1.2.49) - 2025-12-06
 
 ### Other

src/lib.rs

@@ -246,7 +246,7 @@ use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt::{self, Display};
 use std::fs;
-use std::io::{self, Write};
+use std::io;
 use std::path::{Component, Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::{
@@ -1425,25 +1425,6 @@ impl Build {
         )
     }
 
-    fn ensure_check_file(&self) -> Result<PathBuf, Error> {
-        let out_dir = self.get_out_dir()?;
-        let src = if self.cuda {
-            assert!(self.cpp);
-            out_dir.join("flag_check.cu")
-        } else if self.cpp {
-            out_dir.join("flag_check.cpp")
-        } else {
-            out_dir.join("flag_check.c")
-        };
-
-        if !src.exists() {
-            let mut f = fs::File::create(&src)?;
-            write!(f, "int main(void) {{ return 0; }}")?;
-        }
-
-        Ok(src)
-    }
-
     fn is_flag_supported_inner(
         &self,
         flag: &OsStr,
@@ -1467,7 +1448,6 @@ impl Build {
         }
 
         let out_dir = self.get_out_dir()?;
-        let src = self.ensure_check_file()?;
         let obj = out_dir.join("flag_check");
 
         let mut compiler = {
@@ -1499,6 +1479,14 @@ impl Build {
             // Avoid reporting that the arg is unsupported just because the
             // compiler complains that it wasn't used.
             compiler.push_cc_arg("-Wno-unused-command-line-argument".into());
+            // Turn unknown warning options into errors so invalid -W flags are properly rejected
+            compiler.push_cc_arg("-Werror=unknown-warning-option".into());
+        }
+
+        if compiler.is_like_gnu() || compiler.is_like_clang() {
+            // Turn warnings into errors to ensure invalid flags are rejected
+            // (e.g., -std=c++11 for C code, invalid warning flags)
+            compiler.push_cc_arg("-Werror".into());
         }
 
         let mut cmd = compiler.to_command();
@@ -1522,12 +1510,6 @@ impl Build {
         // https://github.com/rust-lang/cc-rs/issues/1423
         cmd.arg("-c");
 
-        if compiler.supports_path_delimiter() {
-            cmd.arg("--");
-        }
-
-        cmd.arg(&src);
-
         if compiler.is_like_msvc() {
             // On MSVC we need to make sure the LIB directory is included
             // so the CRT can be found.
@@ -1539,7 +1521,37 @@ impl Build {
             }
         }
 
-        let output = cmd.current_dir(out_dir).output()?;
+        // Use stdin compilation for all flag tests to avoid issues with
+        // language-specific flags like -xassembler-with-cpp.
+        // See: https://github.com/rust-lang/cc-rs/issues/359
+        let flag_str = flag.to_str().unwrap_or("");
+        let is_language_flag = flag_str.starts_with("-x");
+
+        if !is_language_flag {
+            // For non-language-selection flags, explicitly specify the language
+            // to ensure proper validation (e.g., -std=c++11 should fail for C code)
+            if self.cpp {
+                cmd.arg("-xc++");
+            } else if self.cuda {
+                cmd.arg("-xcuda");
+            } else {
+                cmd.arg("-xc");
+            }
+        }
+        // For language-selection flags (like -xassembler-with-cpp), don't specify
+        // a language - let the flag itself determine it
+
+        cmd.arg("-");
+
+        let mut child = cmd
+            .stdin(std::process::Stdio::piped())
+            .current_dir(&out_dir)
+            .spawn()?;
+
+        // Close stdin immediately (empty input is sufficient for flag validation)
+        drop(child.stdin.take());
+
+        let output = child.wait_with_output()?;
         let is_supported = output.status.success() && output.stderr.is_empty();
 
         self.build_cache

tests/test.rs

@@ -417,6 +417,31 @@ fn gnu_flag_if_supported_cpp() {
     test.cmd(0).must_have("-std=c++11");
 }
 
+// Regression test for issue #359: is_flag_supported should work with
+// language-specific flags (e.g., assembly flags) by using stdin compilation
+// instead of file-based compilation to avoid file extension issues.
+#[cfg(not(windows))]
+#[test]
+fn is_flag_supported_assembly_flags() {
+    let test = Test::gnu();
+
+    // Test that assembly-specific flags are correctly detected as supported
+    let build = test.gcc();
+    let result = build.is_flag_supported("-xassembler-with-cpp");
+    assert!(
+        result.is_ok() && result.unwrap(),
+        "Assembly flag -xassembler-with-cpp should be supported"
+    );
+
+    // Test that normal C flags still work
+    let build = test.gcc();
+    let result = build.is_flag_supported("-Wall");
+    assert!(
+        result.is_ok() && result.unwrap(),
+        "C flag -Wall should be supported"
+    );
+}
+
 #[test]
 fn gnu_static() {
     reset_env();