std.Build: add an option to CSourceFile to override the language detection.

It is normally based on the file extension, but it can be ambiguous.
Notably, ".h" is often used for c or c++.

Author: xxxbxxx

lib/std/Build/Module.zig

@@ -78,21 +78,67 @@ pub const SystemLib = struct {
     pub const SearchStrategy = enum { paths_first, mode_first, no_fallback };
 };
 
+/// Supported languages for "zig clang -x <lang>".
+pub const CSourceLang = enum {
+    /// "c"
+    c,
+    /// "c-header"
+    h,
+    /// "c++"
+    cpp,
+    /// "c++-header"
+    hpp,
+    /// "objective-c"
+    m,
+    /// "objective-c-header"
+    hm,
+    /// "objective-c++"
+    mm,
+    /// "objective-c++-header"
+    hmm,
+    /// "assembler"
+    assembly,
+    /// "assembler-with-cpp"
+    assembly_with_cpp,
+    /// "cuda"
+    cu,
+
+    pub fn getLangName(lang: @This()) []const u8 {
+        return switch (lang) {
+            .assembly => "assembler",
+            .assembly_with_cpp => "assembler-with-cpp",
+            .c => "c",
+            .cpp => "c++",
+            .h => "c-header",
+            .hpp => "c++-header",
+            .hm => "objective-c-header",
+            .hmm => "objective-c++-header",
+            .cu => "cuda",
+            .m => "objective-c",
+            .mm => "objective-c++",
+        };
+    }
+};
+
 pub const CSourceFiles = struct {
     dependency: ?*std.Build.Dependency,
     /// If `dependency` is not null relative to it,
     /// else relative to the build root.
     files: []const []const u8,
+    lang: ?CSourceLang = null,
     flags: []const []const u8,
 };
 
 pub const CSourceFile = struct {
     file: LazyPath,
+    /// `lang` optionally overrides the language detection.
+    lang: ?CSourceLang = null,
     flags: []const []const u8 = &.{},
 
     pub fn dupe(self: CSourceFile, b: *std.Build) CSourceFile {
         return .{
             .file = self.file.dupe(b),
+            .lang = self.lang,
             .flags = b.dupeStrings(self.flags),
         };
     }
@@ -457,6 +503,7 @@ pub const AddCSourceFilesOptions = struct {
     /// package that owns the `Compile` step.
     dependency: ?*std.Build.Dependency = null,
     files: []const []const u8,
+    lang: ?CSourceLang = null,
     flags: []const []const u8 = &.{},
 };
 
@@ -468,6 +515,7 @@ pub fn addCSourceFiles(m: *Module, options: AddCSourceFilesOptions) void {
     c_source_files.* = .{
         .dependency = options.dependency,
         .files = b.dupeStrings(options.files),
+        .lang = options.lang,
         .flags = b.dupeStrings(options.flags),
     };
     m.link_objects.append(allocator, .{ .c_source_files = c_source_files }) catch @panic("OOM");

lib/std/Build/Step/Compile.zig

@@ -1143,6 +1143,12 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                             try zig_args.append("--");
                             prev_has_cflags = true;
                         }
+
+                        if (c_source_file.lang) |lang| {
+                            try zig_args.append("-x");
+                            try zig_args.append(lang.getLangName());
+                        }
+
                         try zig_args.append(c_source_file.file.getPath2(module.owner, step));
                         total_linker_objects += 1;
                     },
@@ -1165,6 +1171,11 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                             prev_has_cflags = true;
                         }
 
+                        if (c_source_files.lang) |lang| {
+                            try zig_args.append("-x");
+                            try zig_args.append(lang.getLangName());
+                        }
+
                         if (c_source_files.dependency) |dep| {
                             for (c_source_files.files) |file| {
                                 try zig_args.append(dep.builder.pathFromRoot(file));