add std.Build.Module.addForeignSourceFile[s]

GalaxyShard · GalaxyShard · commit 2156522a43c1 · 2024-07-20T00:42:43.000-04:00
diff --git a/lib/std/Build/Module.zig b/lib/std/Build/Module.zig
@@ -50,8 +50,8 @@ pub const LinkObject = union(enum) {
     other_step: *Step.Compile,
     system_lib: SystemLib,
     assembly_file: LazyPath,
-    c_source_file: *CSourceFile,
-    c_source_files: *CSourceFiles,
+    foreign_source_file: *ForeignSourceFile,
+    foreign_source_files: *ForeignSourceFiles,
     win32_resource_file: *RcSourceFile,
 };
 
@@ -77,22 +77,49 @@ pub const SystemLib = struct {
     pub const SearchStrategy = enum { paths_first, mode_first, no_fallback };
 };
 
-pub const CSourceFiles = struct {
+pub const ForeignSourceLanguage = enum {
+    c,
+    cpp,
+    assembly,
+    assembly_with_cpp,
+    objc,
+    objcpp,
+
+    find_by_file_extension,
+};
+
+pub const ForeignSourceFiles = struct {
     root: LazyPath,
     /// `files` is relative to `root`, which is
     /// the build root by default
     files: []const []const u8,
     flags: []const []const u8,
+    language: ForeignSourceLanguage,
 };
 
+pub const ForeignSourceFile = struct {
+    file: LazyPath,
+    flags: []const []const u8 = &.{},
+    language: ForeignSourceLanguage,
+
+    pub fn dupe(file: ForeignSourceFile, b: *std.Build) ForeignSourceFile {
+        return .{
+            .file = file.file.dupe(b),
+            .flags = b.dupeStrings(file.flags),
+            .language = file.language,
+        };
+    }
+};
 pub const CSourceFile = struct {
     file: LazyPath,
     flags: []const []const u8 = &.{},
+    language: ForeignSourceLanguage = .find_by_file_extension,
 
     pub fn dupe(file: CSourceFile, b: *std.Build) CSourceFile {
         return .{
             .file = file.file.dupe(b),
             .flags = b.dupeStrings(file.flags),
+            .language = file.language,
         };
     }
 };
@@ -287,10 +314,10 @@ fn addShallowDependencies(m: *Module, dependee: *Module) void {
         .assembly_file,
         => |lp| addLazyPathDependencies(m, dependee, lp),
 
-        .c_source_file => |x| addLazyPathDependencies(m, dependee, x.file),
+        .foreign_source_file => |x| addLazyPathDependencies(m, dependee, x.file),
         .win32_resource_file => |x| addLazyPathDependencies(m, dependee, x.file),
 
-        .c_source_files,
+        .foreign_source_files,
         .system_lib,
         => {},
     };
@@ -477,47 +504,75 @@ pub fn linkFramework(m: *Module, name: []const u8, options: LinkFrameworkOptions
     m.frameworks.put(b.allocator, b.dupe(name), options) catch @panic("OOM");
 }
 
+pub const AddForeignSourceFilesOptions = struct {
+    /// When provided, `files` are relative to `root` rather than the
+    /// package that owns the `Compile` step.
+    root: ?LazyPath = null,
+    files: []const []const u8,
+    flags: []const []const u8 = &.{},
+    language: ForeignSourceLanguage,
+};
 pub const AddCSourceFilesOptions = struct {
     /// When provided, `files` are relative to `root` rather than the
     /// package that owns the `Compile` step.
     root: ?LazyPath = null,
     files: []const []const u8,
     flags: []const []const u8 = &.{},
+    language: ForeignSourceLanguage = .find_by_file_extension,
 };
 
-/// Handy when you have many C/C++ source files and want them all to have the same flags.
-pub fn addCSourceFiles(m: *Module, options: AddCSourceFilesOptions) void {
+/// Handy when you have many non-Zig source files and want them all to have the same flags.
+pub fn addForeignSourceFiles(m: *Module, options: AddForeignSourceFilesOptions) void {
     const b = m.owner;
     const allocator = b.allocator;
 
     for (options.files) |path| {
         if (std.fs.path.isAbsolute(path)) {
             std.debug.panic(
-                "file paths added with 'addCSourceFiles' must be relative, found absolute path '{s}'",
+                "file paths added with 'addForeignSourceFiles' must be relative, found absolute path '{s}'",
                 .{path},
             );
         }
     }
 
-    const c_source_files = allocator.create(CSourceFiles) catch @panic("OOM");
-    c_source_files.* = .{
+    const source_files = allocator.create(ForeignSourceFiles) catch @panic("OOM");
+    source_files.* = .{
         .root = options.root orelse b.path(""),
         .files = b.dupeStrings(options.files),
         .flags = b.dupeStrings(options.flags),
+        .language = options.language,
     };
-    m.link_objects.append(allocator, .{ .c_source_files = c_source_files }) catch @panic("OOM");
-    addLazyPathDependenciesOnly(m, c_source_files.root);
+    m.link_objects.append(allocator, .{ .foreign_source_files = source_files }) catch @panic("OOM");
+    addLazyPathDependenciesOnly(m, source_files.root);
 }
 
-pub fn addCSourceFile(m: *Module, source: CSourceFile) void {
+/// Handy when you have many C/C++ source files and want them all to have the same flags.
+pub fn addCSourceFiles(m: *Module, options: AddCSourceFilesOptions) void {
+    addForeignSourceFiles(m, .{
+        .root = options.root,
+        .files = options.files,
+        .flags = options.flags,
+        .language = options.language,
+    });
+}
+
+pub fn addForeignSourceFile(m: *Module, source: ForeignSourceFile) void {
     const b = m.owner;
     const allocator = b.allocator;
-    const c_source_file = allocator.create(CSourceFile) catch @panic("OOM");
-    c_source_file.* = source.dupe(b);
-    m.link_objects.append(allocator, .{ .c_source_file = c_source_file }) catch @panic("OOM");
+    const source_file = allocator.create(ForeignSourceFile) catch @panic("OOM");
+    source_file.* = source.dupe(b);
+    m.link_objects.append(allocator, .{ .foreign_source_file = source_file }) catch @panic("OOM");
     addLazyPathDependenciesOnly(m, source.file);
 }
 
+pub fn addCSourceFile(m: *Module, source: CSourceFile) void {
+    addForeignSourceFile(m, .{
+        .file = source.file,
+        .flags = source.flags,
+        .language = source.language,
+    });
+}
+
 /// Resource files must have the extension `.rc`.
 /// Can be called regardless of target. The .rc file will be ignored
 /// if the target object format does not support embedded resources.
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
@@ -784,11 +784,18 @@ pub fn linkFrameworkWeak(c: *Compile, name: []const u8) void {
     c.root_module.linkFramework(name, .{ .weak = true });
 }
 
+/// Handy when you have many non-Zig source files and want them all to have the same flags.
+pub fn addForeignSourceFiles(compile: *Compile, options: Module.AddForeignSourceFilesOptions) void {
+    compile.root_module.addForeignSourceFiles(options);
+}
 /// Handy when you have many C/C++ source files and want them all to have the same flags.
 pub fn addCSourceFiles(compile: *Compile, options: Module.AddCSourceFilesOptions) void {
     compile.root_module.addCSourceFiles(options);
 }
 
+pub fn addForeignSourceFile(compile: *Compile, source: Module.ForeignSourceFile) void {
+    compile.root_module.addForeignSourceFile(source);
+}
 pub fn addCSourceFile(compile: *Compile, source: Module.CSourceFile) void {
     compile.root_module.addCSourceFile(source);
 }
@@ -1227,51 +1234,76 @@ fn getZigArgs(compile: *Compile) ![][]const u8 {
                         total_linker_objects += 1;
                     },
 
-                    .c_source_file => |c_source_file| l: {
+                    .foreign_source_file => |foreign_source_file| l: {
                         if (!my_responsibility) break :l;
 
-                        if (c_source_file.flags.len == 0) {
-                            if (prev_has_cflags) {
-                                try zig_args.append("-cflags");
-                                try zig_args.append("--");
-                                prev_has_cflags = false;
-                            }
-                        } else {
+                        if (prev_has_cflags or foreign_source_file.flags.len != 0) {
                             try zig_args.append("-cflags");
-                            for (c_source_file.flags) |arg| {
+                            for (foreign_source_file.flags) |arg| {
                                 try zig_args.append(arg);
                             }
                             try zig_args.append("--");
-                            prev_has_cflags = true;
                         }
-                        try zig_args.append(c_source_file.file.getPath2(dep.module.owner, step));
+                        prev_has_cflags = (foreign_source_file.flags.len != 0);
+
+                        if (foreign_source_file.language != .find_by_file_extension) {
+                            try zig_args.append("-x");
+                            try zig_args.append(switch (foreign_source_file.language) {
+                                .find_by_file_extension => unreachable,
+                                .c => "c",
+                                .cpp => "c++",
+                                .assembly => "assembler",
+                                .assembly_with_cpp => "assembler-with-cpp",
+                                .objc => "objective-c",
+                                .objcpp => "objective-c++",
+                            });
+                        }
+
+                        try zig_args.append(foreign_source_file.file.getPath2(dep.module.owner, step));
+
+                        if (foreign_source_file.language != .find_by_file_extension) {
+                            try zig_args.append("-x");
+                            try zig_args.append("none");
+                        }
                         total_linker_objects += 1;
                     },
 
-                    .c_source_files => |c_source_files| l: {
+                    .foreign_source_files => |foreign_source_files| l: {
                         if (!my_responsibility) break :l;
 
-                        if (c_source_files.flags.len == 0) {
-                            if (prev_has_cflags) {
-                                try zig_args.append("-cflags");
-                                try zig_args.append("--");
-                                prev_has_cflags = false;
-                            }
-                        } else {
+                        if (prev_has_cflags or foreign_source_files.flags.len != 0) {
                             try zig_args.append("-cflags");
-                            for (c_source_files.flags) |flag| {
-                                try zig_args.append(flag);
+                            for (foreign_source_files.flags) |arg| {
+                                try zig_args.append(arg);
                             }
                             try zig_args.append("--");
-                            prev_has_cflags = true;
+                        }
+                        prev_has_cflags = (foreign_source_files.flags.len != 0);
+
+                        if (foreign_source_files.language != .find_by_file_extension) {
+                            try zig_args.append("-x");
+                            try zig_args.append(switch (foreign_source_files.language) {
+                                .find_by_file_extension => unreachable,
+                                .c => "c",
+                                .cpp => "c++",
+                                .assembly => "assembler",
+                                .assembly_with_cpp => "assembler-with-cpp",
+                                .objc => "objective-c",
+                                .objcpp => "objective-c++",
+                            });
                         }
 
-                        const root_path = c_source_files.root.getPath2(dep.module.owner, step);
-                        for (c_source_files.files) |file| {
+                        const root_path = foreign_source_files.root.getPath2(dep.module.owner, step);
+                        for (foreign_source_files.files) |file| {
                             try zig_args.append(b.pathJoin(&.{ root_path, file }));
                         }
 
-                        total_linker_objects += c_source_files.files.len;
+                        if (foreign_source_files.language != .find_by_file_extension) {
+                            try zig_args.append("-x");
+                            try zig_args.append("none");
+                        }
+
+                        total_linker_objects += foreign_source_files.files.len;
                     },
 
                     .win32_resource_file => |rc_source_file| l: {
@@ -1992,7 +2024,7 @@ pub fn rootModuleTarget(c: *Compile) std.Target {
 
 fn moduleNeedsCliArg(mod: *const Module) bool {
     return for (mod.link_objects.items) |o| switch (o) {
-        .c_source_file, .c_source_files, .assembly_file, .win32_resource_file => break true,
+        .foreign_source_file, .foreign_source_files, .assembly_file, .win32_resource_file => break true,
         else => continue,
     } else false;
 }
