std.build: extract steps to separate files

There are intended to be no functional changes in this commit.

lib/std/build/InstallArtifactStep.zig

@@ -0,0 +1,88 @@
+const std = @import("../std.zig");
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const LibExeObjStep = std.build.LibExeObjStep;
+const InstallDir = std.build.InstallDir;
+
+pub const base_id = .install_artifact;
+
+step: Step,
+builder: *Builder,
+artifact: *LibExeObjStep,
+dest_dir: InstallDir,
+pdb_dir: ?InstallDir,
+h_dir: ?InstallDir,
+
+const Self = @This();
+
+pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
+    if (artifact.install_step) |s| return s;
+
+    const self = builder.allocator.create(Self) catch unreachable;
+    self.* = Self{
+        .builder = builder,
+        .step = Step.init(.install_artifact, builder.fmt("install {s}", .{artifact.step.name}), builder.allocator, make),
+        .artifact = artifact,
+        .dest_dir = artifact.override_dest_dir orelse switch (artifact.kind) {
+            .obj => @panic("Cannot install a .obj build artifact."),
+            .@"test" => @panic("Cannot install a test build artifact, use addTestExe instead."),
+            .exe, .test_exe => InstallDir{ .bin = {} },
+            .lib => InstallDir{ .lib = {} },
+        },
+        .pdb_dir = if (artifact.producesPdbFile()) blk: {
+            if (artifact.kind == .exe or artifact.kind == .test_exe) {
+                break :blk InstallDir{ .bin = {} };
+            } else {
+                break :blk InstallDir{ .lib = {} };
+            }
+        } else null,
+        .h_dir = if (artifact.kind == .lib and artifact.emit_h) .header else null,
+    };
+    self.step.dependOn(&artifact.step);
+    artifact.install_step = self;
+
+    builder.pushInstalledFile(self.dest_dir, artifact.out_filename);
+    if (self.artifact.isDynamicLibrary()) {
+        if (artifact.major_only_filename) |name| {
+            builder.pushInstalledFile(.lib, name);
+        }
+        if (artifact.name_only_filename) |name| {
+            builder.pushInstalledFile(.lib, name);
+        }
+        if (self.artifact.target.isWindows()) {
+            builder.pushInstalledFile(.lib, artifact.out_lib_filename);
+        }
+    }
+    if (self.pdb_dir) |pdb_dir| {
+        builder.pushInstalledFile(pdb_dir, artifact.out_pdb_filename);
+    }
+    if (self.h_dir) |h_dir| {
+        builder.pushInstalledFile(h_dir, artifact.out_h_filename);
+    }
+    return self;
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(Self, "step", step);
+    const builder = self.builder;
+
+    const full_dest_path = builder.getInstallPath(self.dest_dir, self.artifact.out_filename);
+    try builder.updateFile(self.artifact.getOutputSource().getPath(builder), full_dest_path);
+    if (self.artifact.isDynamicLibrary() and self.artifact.version != null and self.artifact.target.wantSharedLibSymLinks()) {
+        try LibExeObjStep.doAtomicSymLinks(builder.allocator, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
+    }
+    if (self.artifact.isDynamicLibrary() and self.artifact.target.isWindows() and self.artifact.emit_implib != .no_emit) {
+        const full_implib_path = builder.getInstallPath(self.dest_dir, self.artifact.out_lib_filename);
+        try builder.updateFile(self.artifact.getOutputLibSource().getPath(builder), full_implib_path);
+    }
+    if (self.pdb_dir) |pdb_dir| {
+        const full_pdb_path = builder.getInstallPath(pdb_dir, self.artifact.out_pdb_filename);
+        try builder.updateFile(self.artifact.getOutputPdbSource().getPath(builder), full_pdb_path);
+    }
+    if (self.h_dir) |h_dir| {
+        const full_pdb_path = builder.getInstallPath(h_dir, self.artifact.out_h_filename);
+        try builder.updateFile(self.artifact.getOutputHSource().getPath(builder), full_pdb_path);
+    }
+    self.artifact.installed_path = full_dest_path;
+}

lib/std/build/InstallDirStep.zig

@@ -0,0 +1,90 @@
+const std = @import("../std.zig");
+const mem = std.mem;
+const fs = std.fs;
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const InstallDir = std.build.InstallDir;
+const InstallDirStep = @This();
+
+step: Step,
+builder: *Builder,
+options: Options,
+
+pub const base_id = .install_dir;
+
+pub const Options = struct {
+    source_dir: []const u8,
+    install_dir: InstallDir,
+    install_subdir: []const u8,
+    /// File paths which end in any of these suffixes will be excluded
+    /// from being installed.
+    exclude_extensions: []const []const u8 = &.{},
+    /// File paths which end in any of these suffixes will result in
+    /// empty files being installed. This is mainly intended for large
+    /// test.zig files in order to prevent needless installation bloat.
+    /// However if the files were not present at all, then
+    /// `@import("test.zig")` would be a compile error.
+    blank_extensions: []const []const u8 = &.{},
+
+    fn dupe(self: Options, b: *Builder) Options {
+        return .{
+            .source_dir = b.dupe(self.source_dir),
+            .install_dir = self.install_dir.dupe(b),
+            .install_subdir = b.dupe(self.install_subdir),
+            .exclude_extensions = b.dupeStrings(self.exclude_extensions),
+            .blank_extensions = b.dupeStrings(self.blank_extensions),
+        };
+    }
+};
+
+pub fn init(
+    builder: *Builder,
+    options: Options,
+) InstallDirStep {
+    builder.pushInstalledFile(options.install_dir, options.install_subdir);
+    return InstallDirStep{
+        .builder = builder,
+        .step = Step.init(.install_dir, builder.fmt("install {s}/", .{options.source_dir}), builder.allocator, make),
+        .options = options.dupe(builder),
+    };
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(InstallDirStep, "step", step);
+    const dest_prefix = self.builder.getInstallPath(self.options.install_dir, self.options.install_subdir);
+    const full_src_dir = self.builder.pathFromRoot(self.options.source_dir);
+    var src_dir = try std.fs.cwd().openIterableDir(full_src_dir, .{});
+    defer src_dir.close();
+    var it = try src_dir.walk(self.builder.allocator);
+    next_entry: while (try it.next()) |entry| {
+        for (self.options.exclude_extensions) |ext| {
+            if (mem.endsWith(u8, entry.path, ext)) {
+                continue :next_entry;
+            }
+        }
+
+        const full_path = self.builder.pathJoin(&.{
+            full_src_dir, entry.path,
+        });
+
+        const dest_path = self.builder.pathJoin(&.{
+            dest_prefix, entry.path,
+        });
+
+        switch (entry.kind) {
+            .Directory => try fs.cwd().makePath(dest_path),
+            .File => {
+                for (self.options.blank_extensions) |ext| {
+                    if (mem.endsWith(u8, entry.path, ext)) {
+                        try self.builder.truncateFile(dest_path);
+                        continue :next_entry;
+                    }
+                }
+
+                try self.builder.updateFile(full_path, dest_path);
+            },
+            else => continue,
+        }
+    }
+}

lib/std/build/InstallFileStep.zig

@@ -0,0 +1,38 @@
+const std = @import("../std.zig");
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const FileSource = std.build.FileSource;
+const InstallDir = std.build.InstallDir;
+const InstallFileStep = @This();
+
+pub const base_id = .install_file;
+
+step: Step,
+builder: *Builder,
+source: FileSource,
+dir: InstallDir,
+dest_rel_path: []const u8,
+
+pub fn init(
+    builder: *Builder,
+    source: FileSource,
+    dir: InstallDir,
+    dest_rel_path: []const u8,
+) InstallFileStep {
+    builder.pushInstalledFile(dir, dest_rel_path);
+    return InstallFileStep{
+        .builder = builder,
+        .step = Step.init(.install_file, builder.fmt("install {s} to {s}", .{ source.getDisplayName(), dest_rel_path }), builder.allocator, make),
+        .source = source.dupe(builder),
+        .dir = dir.dupe(builder),
+        .dest_rel_path = builder.dupePath(dest_rel_path),
+    };
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(InstallFileStep, "step", step);
+    const full_dest_path = self.builder.getInstallPath(self.dir, self.dest_rel_path);
+    const full_src_path = self.source.getPath(self.builder);
+    try self.builder.updateFile(full_src_path, full_dest_path);
+}

lib/std/build/LogStep.zig

@@ -0,0 +1,25 @@
+const std = @import("../std.zig");
+const log = std.log;
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const LogStep = @This();
+
+pub const base_id = .log;
+
+step: Step,
+builder: *Builder,
+data: []const u8,
+
+pub fn init(builder: *Builder, data: []const u8) LogStep {
+    return LogStep{
+        .builder = builder,
+        .step = Step.init(.log, builder.fmt("log {s}", .{data}), builder.allocator, make),
+        .data = builder.dupe(data),
+    };
+}
+
+fn make(step: *Step) anyerror!void {
+    const self = @fieldParentPtr(LogStep, "step", step);
+    log.info("{s}", .{self.data});
+}

lib/std/build/RemoveDirStep.zig

@@ -0,0 +1,31 @@
+const std = @import("../std.zig");
+const log = std.log;
+const fs = std.fs;
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const RemoveDirStep = @This();
+
+pub const base_id = .remove_dir;
+
+step: Step,
+builder: *Builder,
+dir_path: []const u8,
+
+pub fn init(builder: *Builder, dir_path: []const u8) RemoveDirStep {
+    return RemoveDirStep{
+        .builder = builder,
+        .step = Step.init(.remove_dir, builder.fmt("RemoveDir {s}", .{dir_path}), builder.allocator, make),
+        .dir_path = builder.dupePath(dir_path),
+    };
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(RemoveDirStep, "step", step);
+
+    const full_path = self.builder.pathFromRoot(self.dir_path);
+    fs.cwd().deleteTree(full_path) catch |err| {
+        log.err("Unable to remove {s}: {s}", .{ full_path, @errorName(err) });
+        return err;
+    };
+}

lib/std/std.zig

@@ -100,36 +100,5 @@ comptime {
 }
 
 test {
-    if (@import("builtin").os.tag == .windows) {
-        // We only test the Windows-relevant stuff to save memory because the CI
-        // server is hitting OOM. TODO revert this after stage2 arrives.
-        _ = ChildProcess;
-        _ = DynLib;
-        _ = Progress;
-        _ = Target;
-        _ = Thread;
-
-        _ = atomic;
-        _ = build;
-        _ = builtin;
-        _ = debug;
-        _ = event;
-        _ = fs;
-        _ = heap;
-        _ = io;
-        _ = log;
-        _ = macho;
-        _ = net;
-        _ = os;
-        _ = once;
-        _ = pdb;
-        _ = process;
-        _ = testing;
-        _ = time;
-        _ = unicode;
-        _ = zig;
-        _ = start;
-    } else {
-        testing.refAllDecls(@This());
-    }
+    testing.refAllDecls(@This());
 }