Commit 3f3b1a6808113fd5f9b2cec1033009cbb17dc969 | zig

build.zig+6-6

...	@@ -533,7 +533,7 @@ fn addCompilerStep(	...	@@ -533,7 +533,7 @@ fn addCompilerStep(
533	b: *std.Build,	533	b: *std.Build,
534	optimize: std.builtin.OptimizeMode,	534	optimize: std.builtin.OptimizeMode,
535	target: std.zig.CrossTarget,	535	target: std.zig.CrossTarget,
536	) *std.Build.CompileStep {	536	) *std.Build.Step.Compile {
537	const exe = b.addExecutable(.{	537	const exe = b.addExecutable(.{
538	.name = "zig",	538	.name = "zig",
539	.root_source_file = .{ .path = "src/main.zig" },	539	.root_source_file = .{ .path = "src/main.zig" },
...	@@ -561,7 +561,7 @@ const exe_cflags = [_][]const u8{	...	@@ -561,7 +561,7 @@ const exe_cflags = [_][]const u8{
561	fn addCmakeCfgOptionsToExe(	561	fn addCmakeCfgOptionsToExe(
562	b: *std.Build,	562	b: *std.Build,
563	cfg: CMakeConfig,	563	cfg: CMakeConfig,
564	exe: *std.Build.CompileStep,	564	exe: *std.Build.Step.Compile,
565	use_zig_libcxx: bool,	565	use_zig_libcxx: bool,
566	) !void {	566	) !void {
567	if (exe.target.isDarwin()) {	567	if (exe.target.isDarwin()) {
...	@@ -640,7 +640,7 @@ fn addCmakeCfgOptionsToExe(	...	@@ -640,7 +640,7 @@ fn addCmakeCfgOptionsToExe(
640	}	640	}
641	}	641	}
642		642
643	fn addStaticLlvmOptionsToExe(exe: *std.Build.CompileStep) !void {	643	fn addStaticLlvmOptionsToExe(exe: *std.Build.Step.Compile) !void {
644	// Adds the Zig C++ sources which both stage1 and stage2 need.	644	// Adds the Zig C++ sources which both stage1 and stage2 need.
645	//	645	//
646	// We need this because otherwise zig_clang_cc1_main.cpp ends up pulling	646	// We need this because otherwise zig_clang_cc1_main.cpp ends up pulling
...	@@ -679,7 +679,7 @@ fn addStaticLlvmOptionsToExe(exe: *std.Build.CompileStep) !void {	...	@@ -679,7 +679,7 @@ fn addStaticLlvmOptionsToExe(exe: *std.Build.CompileStep) !void {
679	fn addCxxKnownPath(	679	fn addCxxKnownPath(
680	b: *std.Build,	680	b: *std.Build,
681	ctx: CMakeConfig,	681	ctx: CMakeConfig,
682	exe: *std.Build.CompileStep,	682	exe: *std.Build.Step.Compile,
683	objname: []const u8,	683	objname: []const u8,
684	errtxt: ?[]const u8,	684	errtxt: ?[]const u8,
685	need_cpp_includes: bool,	685	need_cpp_includes: bool,
...	@@ -709,7 +709,7 @@ fn addCxxKnownPath(	...	@@ -709,7 +709,7 @@ fn addCxxKnownPath(
709	}	709	}
710	}	710	}
711		711
712	fn addCMakeLibraryList(exe: *std.Build.CompileStep, list: []const u8) void {	712	fn addCMakeLibraryList(exe: *std.Build.Step.Compile, list: []const u8) void {
713	var it = mem.tokenize(u8, list, ";");	713	var it = mem.tokenize(u8, list, ";");
714	while (it.next()) \|lib\| {	714	while (it.next()) \|lib\| {
715	if (mem.startsWith(u8, lib, "-l")) {	715	if (mem.startsWith(u8, lib, "-l")) {
...	@@ -723,7 +723,7 @@ fn addCMakeLibraryList(exe: *std.Build.CompileStep, list: []const u8) void {	...	@@ -723,7 +723,7 @@ fn addCMakeLibraryList(exe: *std.Build.CompileStep, list: []const u8) void {
723	}	723	}
724		724
725	const CMakeConfig = struct {	725	const CMakeConfig = struct {
726	llvm_linkage: std.Build.CompileStep.Linkage,	726	llvm_linkage: std.Build.Step.Compile.Linkage,
727	cmake_binary_dir: []const u8,	727	cmake_binary_dir: []const u8,
728	cmake_prefix_path: []const u8,	728	cmake_prefix_path: []const u8,
729	cmake_static_library_prefix: []const u8,	729	cmake_static_library_prefix: []const u8,

lib/init-exe/build.zig+1-1

...	@@ -29,7 +29,7 @@ pub fn build(b: *std.Build) void {	...	@@ -29,7 +29,7 @@ pub fn build(b: *std.Build) void {
29	// step when running `zig build`).	29	// step when running `zig build`).
30	b.installArtifact(exe);	30	b.installArtifact(exe);
31		31
32	// This creates a RunStep in the build graph, to be executed when another	32	// This creates a Run step in the build graph, to be executed when another
33	// step is evaluated that depends on it. The next line below will establish	33	// step is evaluated that depends on it. The next line below will establish
34	// such a dependency.	34	// such a dependency.
35	const run_cmd = b.addRunArtifact(exe);	35	const run_cmd = b.addRunArtifact(exe);

lib/std/Build.zig+76-74

 @@ -21,27 +21,41 @@ const Build = @This();
 pub const Cache = @import("Build/Cache.zig");
-/// deprecated: use `CompileStep`.
+/// deprecated: use `Step.Compile`.
-pub const LibExeObjStep = CompileStep;
+pub const LibExeObjStep = Step.Compile;
 /// deprecated: use `Build`.
 pub const Builder = Build;
-/// deprecated: use `InstallDirStep.Options`
+/// deprecated: use `Step.InstallDir.Options`
-pub const InstallDirectoryOptions = InstallDirStep.Options;
+pub const InstallDirectoryOptions = Step.InstallDir.Options;
 pub const Step = @import("Build/Step.zig");
+/// deprecated: use `Step.CheckFile`.
 pub const CheckFileStep = @import("Build/Step/CheckFile.zig");
+/// deprecated: use `Step.CheckObject`.
 pub const CheckObjectStep = @import("Build/Step/CheckObject.zig");
+/// deprecated: use `Step.ConfigHeader`.
 pub const ConfigHeaderStep = @import("Build/Step/ConfigHeader.zig");
+/// deprecated: use `Step.Fmt`.
 pub const FmtStep = @import("Build/Step/Fmt.zig");
+/// deprecated: use `Step.InstallArtifact`.
 pub const InstallArtifactStep = @import("Build/Step/InstallArtifact.zig");
+/// deprecated: use `Step.InstallDir`.
 pub const InstallDirStep = @import("Build/Step/InstallDir.zig");
+/// deprecated: use `Step.InstallFile`.
 pub const InstallFileStep = @import("Build/Step/InstallFile.zig");
+/// deprecated: use `Step.ObjCopy`.
 pub const ObjCopyStep = @import("Build/Step/ObjCopy.zig");
+/// deprecated: use `Step.Compile`.
 pub const CompileStep = @import("Build/Step/Compile.zig");
+/// deprecated: use `Step.Options`.
 pub const OptionsStep = @import("Build/Step/Options.zig");
+/// deprecated: use `Step.RemoveDir`.
 pub const RemoveDirStep = @import("Build/Step/RemoveDir.zig");
+/// deprecated: use `Step.Run`.
 pub const RunStep = @import("Build/Step/Run.zig");
+/// deprecated: use `Step.TranslateC`.
 pub const TranslateCStep = @import("Build/Step/TranslateC.zig");
+/// deprecated: use `Step.WriteFile`.
 pub const WriteFileStep = @import("Build/Step/WriteFile.zig");
 install_tls: TopLevelStep,
 @@ -442,8 +456,8 @@ pub fn resolveInstallPrefix(self: *Build, install_prefix: ?[]const u8, dir_list:
     self.h_dir = self.pathJoin(&h_list);
 }
-pub fn addOptions(self: *Build) *OptionsStep {
+pub fn addOptions(self: *Build) *Step.Options {
-    return OptionsStep.create(self);
+    return Step.Options.create(self);
 }
 pub const ExecutableOptions = struct {
 @@ -452,7 +466,7 @@ pub const ExecutableOptions = struct {
     version: ?std.builtin.Version = null,
     target: CrossTarget = .{},
     optimize: std.builtin.Mode = .Debug,
-    linkage: ?CompileStep.Linkage = null,
+    linkage: ?Step.Compile.Linkage = null,
     max_rss: usize = 0,
     link_libc: ?bool = null,
     single_threaded: ?bool = null,
 @@ -460,8 +474,8 @@ pub const ExecutableOptions = struct {
     use_lld: ?bool = null,
 };
-pub fn addExecutable(b: *Build, options: ExecutableOptions) *CompileStep {
+pub fn addExecutable(b: *Build, options: ExecutableOptions) *Step.Compile {
-    return CompileStep.create(b, .{
+    return Step.Compile.create(b, .{
         .name = options.name,
         .root_source_file = options.root_source_file,
         .version = options.version,
 @@ -489,8 +503,8 @@ pub const ObjectOptions = struct {
     use_lld: ?bool = null,
 };
-pub fn addObject(b: *Build, options: ObjectOptions) *CompileStep {
+pub fn addObject(b: *Build, options: ObjectOptions) *Step.Compile {
-    return CompileStep.create(b, .{
+    return Step.Compile.create(b, .{
         .name = options.name,
         .root_source_file = options.root_source_file,
         .target = options.target,
 @@ -517,8 +531,8 @@ pub const SharedLibraryOptions = struct {
     use_lld: ?bool = null,
 };
-pub fn addSharedLibrary(b: *Build, options: SharedLibraryOptions) *CompileStep {
+pub fn addSharedLibrary(b: *Build, options: SharedLibraryOptions) *Step.Compile {
-    return CompileStep.create(b, .{
+    return Step.Compile.create(b, .{
         .name = options.name,
         .root_source_file = options.root_source_file,
         .kind = .lib,
 @@ -547,8 +561,8 @@ pub const StaticLibraryOptions = struct {
     use_lld: ?bool = null,
 };
-pub fn addStaticLibrary(b: *Build, options: StaticLibraryOptions) *CompileStep {
+pub fn addStaticLibrary(b: *Build, options: StaticLibraryOptions) *Step.Compile {
-    return CompileStep.create(b, .{
+    return Step.Compile.create(b, .{
         .name = options.name,
         .root_source_file = options.root_source_file,
         .kind = .lib,
 @@ -579,8 +593,8 @@ pub const TestOptions = struct {
     use_lld: ?bool = null,
 };
-pub fn addTest(b: *Build, options: TestOptions) *CompileStep {
+pub fn addTest(b: *Build, options: TestOptions) *Step.Compile {
-    return CompileStep.create(b, .{
+    return Step.Compile.create(b, .{
         .name = options.name,
         .kind = .@"test",
         .root_source_file = options.root_source_file,
 @@ -604,8 +618,8 @@ pub const AssemblyOptions = struct {
     max_rss: usize = 0,
 };
-pub fn addAssembly(b: *Build, options: AssemblyOptions) *CompileStep {
+pub fn addAssembly(b: *Build, options: AssemblyOptions) *Step.Compile {
-    const obj_step = CompileStep.create(b, .{
+    const obj_step = Step.Compile.create(b, .{
         .name = options.name,
         .kind = .obj,
         .root_source_file = null,
 @@ -657,25 +671,25 @@ fn moduleDependenciesToArrayHashMap(arena: Allocator, deps: []const ModuleDepend
     return result;
 }
-/// Initializes a RunStep with argv, which must at least have the path to the
+/// Initializes a `Step.Run` with argv, which must at least have the path to the
 /// executable. More command line arguments can be added with `addArg`,
 /// `addArgs`, and `addArtifactArg`.
 /// Be careful using this function, as it introduces a system dependency.
-/// To run an executable built with zig build, see `CompileStep.run`.
+/// To run an executable built with zig build, see `Step.Compile.run`.
-pub fn addSystemCommand(self: *Build, argv: []const []const u8) *RunStep {
+pub fn addSystemCommand(self: *Build, argv: []const []const u8) *Step.Run {
     assert(argv.len >= 1);
-    const run_step = RunStep.create(self, self.fmt("run {s}", .{argv[0]}));
+    const run_step = Step.Run.create(self, self.fmt("run {s}", .{argv[0]}));
     run_step.addArgs(argv);
     return run_step;
 }
-/// Creates a `RunStep` with an executable built with `addExecutable`.
+/// Creates a `Step.Run` with an executable built with `addExecutable`.
-/// Add command line arguments with methods of `RunStep`.
+/// Add command line arguments with methods of `Step.Run`.
-pub fn addRunArtifact(b: *Build, exe: *CompileStep) *RunStep {
+pub fn addRunArtifact(b: *Build, exe: *Step.Compile) *Step.Run {
     // It doesn't have to be native. We catch that if you actually try to run it.
     // Consider that this is declarative; the run step may not be run unless a user
     // option is supplied.
-    const run_step = RunStep.create(b, b.fmt("run {s}", .{exe.name}));
+    const run_step = Step.Run.create(b, b.fmt("run {s}", .{exe.name}));
     run_step.addArtifactArg(exe);
     if (exe.kind == .@"test") {
 @@ -696,14 +710,14 @@ pub fn addRunArtifact(b: *Build, exe: *CompileStep) *RunStep {
 /// when an option found in the input file is missing from `values`.
 pub fn addConfigHeader(
     b: *Build,
-    options: ConfigHeaderStep.Options,
+    options: Step.ConfigHeader.Options,
     values: anytype,
-) *ConfigHeaderStep {
+) *Step.ConfigHeader {
     var options_copy = options;
     if (options_copy.first_ret_addr == null)
         options_copy.first_ret_addr = @returnAddress();
-    const config_header_step = ConfigHeaderStep.create(b, options_copy);
+    const config_header_step = Step.ConfigHeader.create(b, options_copy);
     config_header_step.addValues(values);
     return config_header_step;
 }
 @@ -734,28 +748,28 @@ pub fn dupePath(self: *Build, bytes: []const u8) []u8 {
     return the_copy;
 }
-pub fn addWriteFile(self: *Build, file_path: []const u8, data: []const u8) *WriteFileStep {
+pub fn addWriteFile(self: *Build, file_path: []const u8, data: []const u8) *Step.WriteFile {
     const write_file_step = self.addWriteFiles();
     write_file_step.add(file_path, data);
     return write_file_step;
 }
-pub fn addWriteFiles(b: *Build) *WriteFileStep {
+pub fn addWriteFiles(b: *Build) *Step.WriteFile {
-    return WriteFileStep.create(b);
+    return Step.WriteFile.create(b);
 }
-pub fn addRemoveDirTree(self: *Build, dir_path: []const u8) *RemoveDirStep {
+pub fn addRemoveDirTree(self: *Build, dir_path: []const u8) *Step.RemoveDir {
-    const remove_dir_step = self.allocator.create(RemoveDirStep) catch @panic("OOM");
+    const remove_dir_step = self.allocator.create(Step.RemoveDir) catch @panic("OOM");
-    remove_dir_step.* = RemoveDirStep.init(self, dir_path);
+    remove_dir_step.* = Step.RemoveDir.init(self, dir_path);
     return remove_dir_step;
 }
-pub fn addFmt(b: *Build, options: FmtStep.Options) *FmtStep {
+pub fn addFmt(b: *Build, options: Step.Fmt.Options) *Step.Fmt {
-    return FmtStep.create(b, options);
+    return Step.Fmt.create(b, options);
 }
-pub fn addTranslateC(self: *Build, options: TranslateCStep.Options) *TranslateCStep {
+pub fn addTranslateC(self: *Build, options: Step.TranslateC.Options) *Step.TranslateC {
-    return TranslateCStep.create(self, options);
+    return Step.TranslateC.create(self, options);
 }
 pub fn getInstallStep(self: *Build) *Step {
 @@ -1213,12 +1227,12 @@ fn printCmd(ally: Allocator, cwd: ?[]const u8, argv: []const []const u8) void {
     std.debug.print("{s}\n", .{text});
 }
-pub fn installArtifact(self: *Build, artifact: *CompileStep) void {
+pub fn installArtifact(self: *Build, artifact: *Step.Compile) void {
     self.getInstallStep().dependOn(&self.addInstallArtifact(artifact).step);
 }
-pub fn addInstallArtifact(self: *Build, artifact: *CompileStep) *InstallArtifactStep {
+pub fn addInstallArtifact(self: *Build, artifact: *Step.Compile) *Step.InstallArtifact {
-    return InstallArtifactStep.create(self, artifact);
+    return Step.InstallArtifact.create(self, artifact);
 }
 ///`dest_rel_path` is relative to prefix path
 @@ -1240,26 +1254,26 @@ pub fn installLibFile(self: *Build, src_path: []const u8, dest_rel_path: []const
     self.getInstallStep().dependOn(&self.addInstallFileWithDir(.{ .path = src_path }, .lib, dest_rel_path).step);
 }
-pub fn addObjCopy(b: *Build, source: FileSource, options: ObjCopyStep.Options) *ObjCopyStep {
+pub fn addObjCopy(b: *Build, source: FileSource, options: Step.ObjCopy.Options) *Step.ObjCopy {
-    return ObjCopyStep.create(b, source, options);
+    return Step.ObjCopy.create(b, source, options);
 }
 ///`dest_rel_path` is relative to install prefix path
-pub fn addInstallFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *InstallFileStep {
+pub fn addInstallFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *Step.InstallFile {
     return self.addInstallFileWithDir(source.dupe(self), .prefix, dest_rel_path);
 }
 ///`dest_rel_path` is relative to bin path
-pub fn addInstallBinFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *InstallFileStep {
+pub fn addInstallBinFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *Step.InstallFile {
     return self.addInstallFileWithDir(source.dupe(self), .bin, dest_rel_path);
 }
 ///`dest_rel_path` is relative to lib path
-pub fn addInstallLibFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *InstallFileStep {
+pub fn addInstallLibFile(self: *Build, source: FileSource, dest_rel_path: []const u8) *Step.InstallFile {
     return self.addInstallFileWithDir(source.dupe(self), .lib, dest_rel_path);
 }
-pub fn addInstallHeaderFile(b: *Build, src_path: []const u8, dest_rel_path: []const u8) *InstallFileStep {
+pub fn addInstallHeaderFile(b: *Build, src_path: []const u8, dest_rel_path: []const u8) *Step.InstallFile {
     return b.addInstallFileWithDir(.{ .path = src_path }, .header, dest_rel_path);
 }
 @@ -1268,22 +1282,22 @@ pub fn addInstallFileWithDir(
     source: FileSource,
     install_dir: InstallDir,
     dest_rel_path: []const u8,
-) *InstallFileStep {
+) *Step.InstallFile {
-    return InstallFileStep.create(self, source.dupe(self), install_dir, dest_rel_path);
+    return Step.InstallFile.create(self, source.dupe(self), install_dir, dest_rel_path);
 }
-pub fn addInstallDirectory(self: *Build, options: InstallDirectoryOptions) *InstallDirStep {
+pub fn addInstallDirectory(self: *Build, options: InstallDirectoryOptions) *Step.InstallDir {
-    const install_step = self.allocator.create(InstallDirStep) catch @panic("OOM");
+    const install_step = self.allocator.create(Step.InstallDir) catch @panic("OOM");
-    install_step.* = InstallDirStep.init(self, options);
+    install_step.* = Step.InstallDir.init(self, options);
     return install_step;
 }
 pub fn addCheckFile(
     b: *Build,
     file_source: FileSource,
-    options: CheckFileStep.Options,
+    options: Step.CheckFile.Options,
-) *CheckFileStep {
+) *Step.CheckFile {
-    return CheckFileStep.create(b, file_source, options);
+    return Step.CheckFile.create(b, file_source, options);
 }
 pub fn pushInstalledFile(self: *Build, dir: InstallDir, dest_rel_path: []const u8) void {
 @@ -1453,10 +1467,10 @@ pub fn getInstallPath(self: *Build, dir: InstallDir, dest_rel_path: []const u8)
 pub const Dependency = struct {
     builder: *Build,
-    pub fn artifact(d: *Dependency, name: []const u8) *CompileStep {
+    pub fn artifact(d: *Dependency, name: []const u8) *Step.Compile {
-        var found: ?*CompileStep = null;
+        var found: ?*Step.Compile = null;
         for (d.builder.install_tls.step.dependencies.items) |dep_step| {
-            const inst = dep_step.cast(InstallArtifactStep) orelse continue;
+            const inst = dep_step.cast(Step.InstallArtifact) orelse continue;
             if (mem.eql(u8, inst.artifact.name, name)) {
                 if (found != null) panic("artifact name '{s}' is ambiguous", .{name});
                 found = inst.artifact;
 @@ -1464,7 +1478,7 @@ pub const Dependency = struct {
         }
         return found orelse {
             for (d.builder.install_tls.step.dependencies.items) |dep_step| {
-                const inst = dep_step.cast(InstallArtifactStep) orelse continue;
+                const inst = dep_step.cast(Step.InstallArtifact) orelse continue;
                 log.info("available artifact: '{s}'", .{inst.artifact.name});
             }
             panic("unable to find artifact '{s}'", .{name});
 @@ -1808,17 +1822,5 @@ pub fn hex64(x: u64) [16]u8 {
 }
 test {
-    _ = CheckFileStep;
+    _ = Step;
-    _ = CheckObjectStep;
-    _ = FmtStep;
-    _ = InstallArtifactStep;
-    _ = InstallDirStep;
-    _ = InstallFileStep;
-    _ = ObjCopyStep;
-    _ = CompileStep;
-    _ = OptionsStep;
-    _ = RemoveDirStep;
-    _ = RunStep;
-    _ = TranslateCStep;
-    _ = WriteFileStep;
 }

lib/std/Build/Step.zig+49-18

 @@ -94,26 +94,41 @@ pub const Id = enum {
     pub fn Type(comptime id: Id) type {
         return switch (id) {
             .top_level => Build.TopLevelStep,
-            .compile => Build.CompileStep,
+            .compile => Compile,
-            .install_artifact => Build.InstallArtifactStep,
+            .install_artifact => InstallArtifact,
-            .install_file => Build.InstallFileStep,
+            .install_file => InstallFile,
-            .install_dir => Build.InstallDirStep,
+            .install_dir => InstallDir,
-            .remove_dir => Build.RemoveDirStep,
+            .remove_dir => RemoveDir,
-            .fmt => Build.FmtStep,
+            .fmt => Fmt,
-            .translate_c => Build.TranslateCStep,
+            .translate_c => TranslateC,
-            .write_file => Build.WriteFileStep,
+            .write_file => WriteFile,
-            .run => Build.RunStep,
+            .run => Run,
-            .check_file => Build.CheckFileStep,
+            .check_file => CheckFile,
-            .check_object => Build.CheckObjectStep,
+            .check_object => CheckObject,
-            .config_header => Build.ConfigHeaderStep,
+            .config_header => ConfigHeader,
-            .objcopy => Build.ObjCopyStep,
+            .objcopy => ObjCopy,
-            .options => Build.OptionsStep,
+            .options => Options,
             .custom => @compileError("no type available for custom step"),
         };
     }
 };
-pub const Options = struct {
+pub const CheckFile = @import("Step/CheckFile.zig");
+pub const CheckObject = @import("Step/CheckObject.zig");
+pub const ConfigHeader = @import("Step/ConfigHeader.zig");
+pub const Fmt = @import("Step/Fmt.zig");
+pub const InstallArtifact = @import("Step/InstallArtifact.zig");
+pub const InstallDir = @import("Step/InstallDir.zig");
+pub const InstallFile = @import("Step/InstallFile.zig");
+pub const ObjCopy = @import("Step/ObjCopy.zig");
+pub const Compile = @import("Step/Compile.zig");
+pub const Options = @import("Step/Options.zig");
+pub const RemoveDir = @import("Step/RemoveDir.zig");
+pub const Run = @import("Step/Run.zig");
+pub const TranslateC = @import("Step/TranslateC.zig");
+pub const WriteFile = @import("Step/WriteFile.zig");
+pub const StepOptions = struct {
     id: Id,
     name: []const u8,
     owner: *Build,
 @@ -122,7 +137,7 @@ pub const Options = struct {
     max_rss: usize = 0,
 };
-pub fn init(options: Options) Step {
+pub fn init(options: StepOptions) Step {
     const arena = options.owner.allocator;
     var addresses = [1]usize{0} ** n_debug_stack_frames;
 @@ -387,8 +402,8 @@ pub fn evalZigProcess(
     s.result_duration_ns = timer.read();
     s.result_peak_rss = child.resource_usage_statistics.getMaxRss() orelse 0;
-    // Special handling for CompileStep that is expecting compile errors.
+    // Special handling for Compile step that is expecting compile errors.
-    if (s.cast(Build.CompileStep)) |compile| switch (term) {
+    if (s.cast(Compile)) |compile| switch (term) {
         .Exited => {
             // Note that the exit code may be 0 in this case due to the
             // compiler server protocol.
 @@ -535,3 +550,19 @@ pub fn writeManifest(s: *Step, man: *std.Build.Cache.Manifest) !void {
         };
     }
 }
+test {
+    _ = CheckFile;
+    _ = CheckObject;
+    _ = Fmt;
+    _ = InstallArtifact;
+    _ = InstallDir;
+    _ = InstallFile;
+    _ = ObjCopy;
+    _ = Compile;
+    _ = Options;
+    _ = RemoveDir;
+    _ = Run;
+    _ = TranslateC;
+    _ = WriteFile;
+}

lib/std/Build/Step/CheckFile.zig+6-6

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	//! Fail the build step if a file does not match certain checks.	1	//! Fail the build step if a file does not match certain checks.
2	//! TODO: make this more flexible, supporting more kinds of checks.	2	//! TODO: make this more flexible, supporting more kinds of checks.
3	//! TODO: generalize the code in std.testing.expectEqualStrings and make this	3	//! TODO: generalize the code in std.testing.expectEqualStrings and make this
4	//! CheckFileStep produce those helpful diagnostics when there is not a match.	4	//! CheckFile step produce those helpful diagnostics when there is not a match.
5	const CheckFileStep = @This();	5	const CheckFile = @This();
6	const std = @import("std");	6	const std = @import("std");
7	const Step = std.Build.Step;	7	const Step = std.Build.Step;
8	const fs = std.fs;	8	const fs = std.fs;
...	@@ -25,8 +25,8 @@ pub fn create(	...	@@ -25,8 +25,8 @@ pub fn create(
25	owner: *std.Build,	25	owner: *std.Build,
26	source: std.Build.FileSource,	26	source: std.Build.FileSource,
27	options: Options,	27	options: Options,
28	) *CheckFileStep {	28	) *CheckFile {
29	const self = owner.allocator.create(CheckFileStep) catch @panic("OOM");	29	const self = owner.allocator.create(CheckFile) catch @panic("OOM");
30	self.* = .{	30	self.* = .{
31	.step = Step.init(.{	31	.step = Step.init(.{
32	.id = .check_file,	32	.id = .check_file,
...	@@ -42,14 +42,14 @@ pub fn create(	...	@@ -42,14 +42,14 @@ pub fn create(
42	return self;	42	return self;
43	}	43	}
44		44
45	pub fn setName(self: *CheckFileStep, name: []const u8) void {	45	pub fn setName(self: *CheckFile, name: []const u8) void {
46	self.step.name = name;	46	self.step.name = name;
47	}	47	}
48		48
49	fn make(step: Step, prog_node: std.Progress.Node) !void {	49	fn make(step: Step, prog_node: std.Progress.Node) !void {
50	_ = prog_node;	50	_ = prog_node;
51	const b = step.owner;	51	const b = step.owner;
52	const self = @fieldParentPtr(CheckFileStep, "step", step);	52	const self = @fieldParentPtr(CheckFile, "step", step);
53		53
54	const src_path = self.source.getPath(b);	54	const src_path = self.source.getPath(b);
55	const contents = fs.cwd().readFileAlloc(b.allocator, src_path, self.max_bytes) catch \|err\| {	55	const contents = fs.cwd().readFileAlloc(b.allocator, src_path, self.max_bytes) catch \|err\| {

lib/std/Build/Step/CheckObject.zig+14-14

lib/std/Build/Step/Compile.zig+81-87

 @@ -18,14 +18,8 @@ const ExecError = std.Build.ExecError;
 const Module = std.Build.Module;
 const VcpkgRoot = std.Build.VcpkgRoot;
 const InstallDir = std.Build.InstallDir;
-const InstallArtifactStep = std.Build.InstallArtifactStep;
 const GeneratedFile = std.Build.GeneratedFile;
-const ObjCopyStep = std.Build.ObjCopyStep;
+const Compile = @This();
-const CheckObjectStep = std.Build.CheckObjectStep;
-const RunStep = std.Build.RunStep;
-const OptionsStep = std.Build.OptionsStep;
-const ConfigHeaderStep = std.Build.ConfigHeaderStep;
-const CompileStep = @This();
 pub const base_id: Step.Id = .compile;
 @@ -211,8 +205,8 @@ want_lto: ?bool = null,
 use_llvm: ?bool,
 use_lld: ?bool,
-/// This is an advanced setting that can change the intent of this CompileStep.
+/// This is an advanced setting that can change the intent of this Compile step.
-/// If this slice has nonzero length, it means that this CompileStep exists to
+/// If this slice has nonzero length, it means that this Compile step exists to
 /// check for compile errors and return *success* if they match, and failure
 /// otherwise.
 expect_errors: []const []const u8 = &.{},
 @@ -242,7 +236,7 @@ pub const CSourceFile = struct {
 pub const LinkObject = union(enum) {
     static_path: FileSource,
-    other_step: *CompileStep,
+    other_step: *Compile,
     system_lib: SystemLib,
     assembly_file: FileSource,
     c_source_file: *CSourceFile,
 @@ -273,8 +267,8 @@ const FrameworkLinkInfo = struct {
 pub const IncludeDir = union(enum) {
     raw_path: []const u8,
     raw_path_system: []const u8,
-    other_step: *CompileStep,
+    other_step: *Compile,
-    config_header_step: *ConfigHeaderStep,
+    config_header_step: *Step.ConfigHeader,
 };
 pub const Options = struct {
 @@ -319,7 +313,7 @@ pub const EmitOption = union(enum) {
     }
 };
-pub fn create(owner: *std.Build, options: Options) *CompileStep {
+pub fn create(owner: *std.Build, options: Options) *Compile {
     const name = owner.dupe(options.name);
     const root_src: ?FileSource = if (options.root_source_file) |rsrc| rsrc.dupe(owner) else null;
     if (mem.indexOf(u8, name, "/") != null or mem.indexOf(u8, name, "\\") != null) {
 @@ -361,8 +355,8 @@ pub fn create(owner: *std.Build, options: Options) *CompileStep {
         .version = options.version,
     }) catch @panic("OOM");
-    const self = owner.allocator.create(CompileStep) catch @panic("OOM");
+    const self = owner.allocator.create(Compile) catch @panic("OOM");
-    self.* = CompileStep{
+    self.* = Compile{
         .strip = null,
         .unwind_tables = null,
         .verbose_link = false,
 @@ -459,7 +453,7 @@ pub fn create(owner: *std.Build, options: Options) *CompileStep {
     return self;
 }
-pub fn installHeader(cs: *CompileStep, src_path: []const u8, dest_rel_path: []const u8) void {
+pub fn installHeader(cs: *Compile, src_path: []const u8, dest_rel_path: []const u8) void {
     const b = cs.step.owner;
     const install_file = b.addInstallHeaderFile(src_path, dest_rel_path);
     b.getInstallStep().dependOn(&install_file.step);
 @@ -472,8 +466,8 @@ pub const InstallConfigHeaderOptions = struct {
 };
 pub fn installConfigHeader(
-    cs: *CompileStep,
+    cs: *Compile,
-    config_header: *ConfigHeaderStep,
+    config_header: *Step.ConfigHeader,
     options: InstallConfigHeaderOptions,
 ) void {
     const dest_rel_path = options.dest_rel_path orelse config_header.include_path;
 @@ -489,7 +483,7 @@ pub fn installConfigHeader(
 }
 pub fn installHeadersDirectory(
-    a: *CompileStep,
+    a: *Compile,
     src_dir_path: []const u8,
     dest_rel_path: []const u8,
 ) void {
 @@ -501,8 +495,8 @@ pub fn installHeadersDirectory(
 }
 pub fn installHeadersDirectoryOptions(
-    cs: *CompileStep,
+    cs: *Compile,
-    options: std.Build.InstallDirStep.Options,
+    options: std.Build.Step.InstallDir.Options,
 ) void {
     const b = cs.step.owner;
     const install_dir = b.addInstallDirectory(options);
 @@ -510,7 +504,7 @@ pub fn installHeadersDirectoryOptions(
     cs.installed_headers.append(&install_dir.step) catch @panic("OOM");
 }
-pub fn installLibraryHeaders(cs: *CompileStep, l: *CompileStep) void {
+pub fn installLibraryHeaders(cs: *Compile, l: *Compile) void {
     assert(l.kind == .lib);
     const b = cs.step.owner;
     const install_step = b.getInstallStep();
 @@ -533,7 +527,7 @@ pub fn installLibraryHeaders(cs: *CompileStep, l: *CompileStep) void {
     cs.installed_headers.appendSlice(l.installed_headers.items) catch @panic("OOM");
 }
-pub fn addObjCopy(cs: *CompileStep, options: ObjCopyStep.Options) *ObjCopyStep {
+pub fn addObjCopy(cs: *Compile, options: Step.ObjCopy.Options) *Step.ObjCopy {
     const b = cs.step.owner;
     var copy = options;
     if (copy.basename == null) {
 @@ -554,34 +548,34 @@ pub const run = @compileError("deprecated; use std.Build.addRunArtifact");
 /// which is undesirable when installing an artifact provided by a dependency package.
 pub const install = @compileError("deprecated; use std.Build.installArtifact");
-pub fn checkObject(self: *CompileStep) *CheckObjectStep {
+pub fn checkObject(self: *Compile) *Step.CheckObject {
-    return CheckObjectStep.create(self.step.owner, self.getOutputSource(), self.target_info.target.ofmt);
+    return Step.CheckObject.create(self.step.owner, self.getOutputSource(), self.target_info.target.ofmt);
 }
-pub fn setLinkerScriptPath(self: *CompileStep, source: FileSource) void {
+pub fn setLinkerScriptPath(self: *Compile, source: FileSource) void {
     const b = self.step.owner;
     self.linker_script = source.dupe(b);
     source.addStepDependencies(&self.step);
 }
-pub fn forceUndefinedSymbol(self: *CompileStep, symbol_name: []const u8) void {
+pub fn forceUndefinedSymbol(self: *Compile, symbol_name: []const u8) void {
     const b = self.step.owner;
     self.force_undefined_symbols.put(b.dupe(symbol_name), {}) catch @panic("OOM");
 }
-pub fn linkFramework(self: *CompileStep, framework_name: []const u8) void {
+pub fn linkFramework(self: *Compile, framework_name: []const u8) void {
     const b = self.step.owner;
     self.frameworks.put(b.dupe(framework_name), .{}) catch @panic("OOM");
 }
-pub fn linkFrameworkNeeded(self: *CompileStep, framework_name: []const u8) void {
+pub fn linkFrameworkNeeded(self: *Compile, framework_name: []const u8) void {
     const b = self.step.owner;
     self.frameworks.put(b.dupe(framework_name), .{
         .needed = true,
     }) catch @panic("OOM");
 }
-pub fn linkFrameworkWeak(self: *CompileStep, framework_name: []const u8) void {
+pub fn linkFrameworkWeak(self: *Compile, framework_name: []const u8) void {
     const b = self.step.owner;
     self.frameworks.put(b.dupe(framework_name), .{
         .weak = true,
 @@ -589,7 +583,7 @@ pub fn linkFrameworkWeak(self: *CompileStep, framework_name: []const u8) void {
 }
 /// Returns whether the library, executable, or object depends on a particular system library.
-pub fn dependsOnSystemLibrary(self: CompileStep, name: []const u8) bool {
+pub fn dependsOnSystemLibrary(self: Compile, name: []const u8) bool {
     if (isLibCLibrary(name)) {
         return self.is_linking_libc;
     }
 @@ -605,51 +599,51 @@ pub fn dependsOnSystemLibrary(self: CompileStep, name: []const u8) bool {
     return false;
 }
-pub fn linkLibrary(self: *CompileStep, lib: *CompileStep) void {
+pub fn linkLibrary(self: *Compile, lib: *Compile) void {
     assert(lib.kind == .lib);
     self.linkLibraryOrObject(lib);
 }
-pub fn isDynamicLibrary(self: *CompileStep) bool {
+pub fn isDynamicLibrary(self: *Compile) bool {
     return self.kind == .lib and self.linkage == Linkage.dynamic;
 }
-pub fn isStaticLibrary(self: *CompileStep) bool {
+pub fn isStaticLibrary(self: *Compile) bool {
     return self.kind == .lib and self.linkage != Linkage.dynamic;
 }
-pub fn producesPdbFile(self: *CompileStep) bool {
+pub fn producesPdbFile(self: *Compile) bool {
     if (!self.target.isWindows() and !self.target.isUefi()) return false;
     if (self.target.getObjectFormat() == .c) return false;
     if (self.strip == true) return false;
     return self.isDynamicLibrary() or self.kind == .exe or self.kind == .@"test";
 }
-pub fn linkLibC(self: *CompileStep) void {
+pub fn linkLibC(self: *Compile) void {
     self.is_linking_libc = true;
 }
-pub fn linkLibCpp(self: *CompileStep) void {
+pub fn linkLibCpp(self: *Compile) void {
     self.is_linking_libcpp = true;
 }
 /// If the value is omitted, it is set to 1.
 /// `name` and `value` need not live longer than the function call.
-pub fn defineCMacro(self: *CompileStep, name: []const u8, value: ?[]const u8) void {
+pub fn defineCMacro(self: *Compile, name: []const u8, value: ?[]const u8) void {
     const b = self.step.owner;
     const macro = std.Build.constructCMacro(b.allocator, name, value);
     self.c_macros.append(macro) catch @panic("OOM");
 }
 /// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.
-pub fn defineCMacroRaw(self: *CompileStep, name_and_value: []const u8) void {
+pub fn defineCMacroRaw(self: *Compile, name_and_value: []const u8) void {
     const b = self.step.owner;
     self.c_macros.append(b.dupe(name_and_value)) catch @panic("OOM");
 }
 /// This one has no integration with anything, it just puts -lname on the command line.
 /// Prefer to use `linkSystemLibrary` instead.
-pub fn linkSystemLibraryName(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibraryName(self: *Compile, name: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
 @@ -663,7 +657,7 @@ pub fn linkSystemLibraryName(self: *CompileStep, name: []const u8) void {
 /// This one has no integration with anything, it just puts -needed-lname on the command line.
 /// Prefer to use `linkSystemLibraryNeeded` instead.
-pub fn linkSystemLibraryNeededName(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibraryNeededName(self: *Compile, name: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
 @@ -677,7 +671,7 @@ pub fn linkSystemLibraryNeededName(self: *CompileStep, name: []const u8) void {
 /// Darwin-only. This one has no integration with anything, it just puts -weak-lname on the
 /// command line. Prefer to use `linkSystemLibraryWeak` instead.
-pub fn linkSystemLibraryWeakName(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibraryWeakName(self: *Compile, name: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
 @@ -691,7 +685,7 @@ pub fn linkSystemLibraryWeakName(self: *CompileStep, name: []const u8) void {
 /// This links against a system library, exclusively using pkg-config to find the library.
 /// Prefer to use `linkSystemLibrary` instead.
-pub fn linkSystemLibraryPkgConfigOnly(self: *CompileStep, lib_name: []const u8) void {
+pub fn linkSystemLibraryPkgConfigOnly(self: *Compile, lib_name: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
 @@ -705,7 +699,7 @@ pub fn linkSystemLibraryPkgConfigOnly(self: *CompileStep, lib_name: []const u8)
 /// This links against a system library, exclusively using pkg-config to find the library.
 /// Prefer to use `linkSystemLibraryNeeded` instead.
-pub fn linkSystemLibraryNeededPkgConfigOnly(self: *CompileStep, lib_name: []const u8) void {
+pub fn linkSystemLibraryNeededPkgConfigOnly(self: *Compile, lib_name: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
 @@ -719,7 +713,7 @@ pub fn linkSystemLibraryNeededPkgConfigOnly(self: *CompileStep, lib_name: []cons
 /// Run pkg-config for the given library name and parse the output, returning the arguments
 /// that should be passed to zig to link the given library.
-fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u8 {
+fn runPkgConfig(self: *Compile, lib_name: []const u8) ![]const []const u8 {
     const b = self.step.owner;
     const pkg_name = match: {
         // First we have to map the library name to pkg config name. Unfortunately,
 @@ -813,19 +807,19 @@ fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u8 {
     return zig_args.toOwnedSlice();
 }
-pub fn linkSystemLibrary(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibrary(self: *Compile, name: []const u8) void {
     self.linkSystemLibraryInner(name, .{});
 }
-pub fn linkSystemLibraryNeeded(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibraryNeeded(self: *Compile, name: []const u8) void {
     self.linkSystemLibraryInner(name, .{ .needed = true });
 }
-pub fn linkSystemLibraryWeak(self: *CompileStep, name: []const u8) void {
+pub fn linkSystemLibraryWeak(self: *Compile, name: []const u8) void {
     self.linkSystemLibraryInner(name, .{ .weak = true });
 }
-fn linkSystemLibraryInner(self: *CompileStep, name: []const u8, opts: struct {
+fn linkSystemLibraryInner(self: *Compile, name: []const u8, opts: struct {
     needed: bool = false,
     weak: bool = false,
 }) void {
 @@ -850,7 +844,7 @@ fn linkSystemLibraryInner(self: *CompileStep, name: []const u8, opts: struct {
 }
 /// Handy when you have many C/C++ source files and want them all to have the same flags.
-pub fn addCSourceFiles(self: *CompileStep, files: []const []const u8, flags: []const []const u8) void {
+pub fn addCSourceFiles(self: *Compile, files: []const []const u8, flags: []const []const u8) void {
     const b = self.step.owner;
     const c_source_files = b.allocator.create(CSourceFiles) catch @panic("OOM");
 @@ -864,14 +858,14 @@ pub fn addCSourceFiles(self: *CompileStep, files: []const []const u8, flags: []c
     self.link_objects.append(.{ .c_source_files = c_source_files }) catch @panic("OOM");
 }
-pub fn addCSourceFile(self: *CompileStep, file: []const u8, flags: []const []const u8) void {
+pub fn addCSourceFile(self: *Compile, file: []const u8, flags: []const []const u8) void {
     self.addCSourceFileSource(.{
         .args = flags,
         .source = .{ .path = file },
     });
 }
-pub fn addCSourceFileSource(self: *CompileStep, source: CSourceFile) void {
+pub fn addCSourceFileSource(self: *Compile, source: CSourceFile) void {
     const b = self.step.owner;
     const c_source_file = b.allocator.create(CSourceFile) catch @panic("OOM");
     c_source_file.* = source.dupe(b);
 @@ -879,85 +873,85 @@ pub fn addCSourceFileSource(self: *CompileStep, source: CSourceFile) void {
     source.source.addStepDependencies(&self.step);
 }
-pub fn setVerboseLink(self: *CompileStep, value: bool) void {
+pub fn setVerboseLink(self: *Compile, value: bool) void {
     self.verbose_link = value;
 }
-pub fn setVerboseCC(self: *CompileStep, value: bool) void {
+pub fn setVerboseCC(self: *Compile, value: bool) void {
     self.verbose_cc = value;
 }
-pub fn overrideZigLibDir(self: *CompileStep, dir_path: []const u8) void {
+pub fn overrideZigLibDir(self: *Compile, dir_path: []const u8) void {
     const b = self.step.owner;
     self.zig_lib_dir = b.dupePath(dir_path);
 }
-pub fn setMainPkgPath(self: *CompileStep, dir_path: []const u8) void {
+pub fn setMainPkgPath(self: *Compile, dir_path: []const u8) void {
     const b = self.step.owner;
     self.main_pkg_path = b.dupePath(dir_path);
 }
-pub fn setLibCFile(self: *CompileStep, libc_file: ?FileSource) void {
+pub fn setLibCFile(self: *Compile, libc_file: ?FileSource) void {
     const b = self.step.owner;
     self.libc_file = if (libc_file) |f| f.dupe(b) else null;
 }
 /// Returns the generated executable, library or object file.
 /// To run an executable built with zig build, use `run`, or create an install step and invoke it.
-pub fn getOutputSource(self: *CompileStep) FileSource {
+pub fn getOutputSource(self: *Compile) FileSource {
     return .{ .generated = &self.output_path_source };
 }
-pub fn getOutputDirectorySource(self: *CompileStep) FileSource {
+pub fn getOutputDirectorySource(self: *Compile) FileSource {
     return .{ .generated = &self.output_dirname_source };
 }
 /// Returns the generated import library. This function can only be called for libraries.
-pub fn getOutputLibSource(self: *CompileStep) FileSource {
+pub fn getOutputLibSource(self: *Compile) FileSource {
     assert(self.kind == .lib);
     return .{ .generated = &self.output_lib_path_source };
 }
 /// Returns the generated header file.
 /// This function can only be called for libraries or object files which have `emit_h` set.
-pub fn getOutputHSource(self: *CompileStep) FileSource {
+pub fn getOutputHSource(self: *Compile) FileSource {
     assert(self.kind != .exe and self.kind != .@"test");
     assert(self.emit_h);
     return .{ .generated = &self.output_h_path_source };
 }
 /// Returns the generated PDB file. This function can only be called for Windows and UEFI.
-pub fn getOutputPdbSource(self: *CompileStep) FileSource {
+pub fn getOutputPdbSource(self: *Compile) FileSource {
     // TODO: Is this right? Isn't PDB for *any* PE/COFF file?
     assert(self.target.isWindows() or self.target.isUefi());
     return .{ .generated = &self.output_pdb_path_source };
 }
-pub fn addAssemblyFile(self: *CompileStep, path: []const u8) void {
+pub fn addAssemblyFile(self: *Compile, path: []const u8) void {
     const b = self.step.owner;
     self.link_objects.append(.{
         .assembly_file = .{ .path = b.dupe(path) },
     }) catch @panic("OOM");
 }
-pub fn addAssemblyFileSource(self: *CompileStep, source: FileSource) void {
+pub fn addAssemblyFileSource(self: *Compile, source: FileSource) void {
     const b = self.step.owner;
     const source_duped = source.dupe(b);
     self.link_objects.append(.{ .assembly_file = source_duped }) catch @panic("OOM");
     source_duped.addStepDependencies(&self.step);
 }
-pub fn addObjectFile(self: *CompileStep, source_file: []const u8) void {
+pub fn addObjectFile(self: *Compile, source_file: []const u8) void {
     self.addObjectFileSource(.{ .path = source_file });
 }
-pub fn addObjectFileSource(self: *CompileStep, source: FileSource) void {
+pub fn addObjectFileSource(self: *Compile, source: FileSource) void {
     const b = self.step.owner;
     self.link_objects.append(.{ .static_path = source.dupe(b) }) catch @panic("OOM");
     source.addStepDependencies(&self.step);
 }
-pub fn addObject(self: *CompileStep, obj: *CompileStep) void {
+pub fn addObject(self: *Compile, obj: *Compile) void {
     assert(obj.kind == .obj);
     self.linkLibraryOrObject(obj);
 }
 @@ -967,54 +961,54 @@ pub const addIncludeDir = @compileError("deprecated; use addIncludePath");
 pub const addLibPath = @compileError("deprecated, use addLibraryPath");
 pub const addFrameworkDir = @compileError("deprecated, use addFrameworkPath");
-pub fn addSystemIncludePath(self: *CompileStep, path: []const u8) void {
+pub fn addSystemIncludePath(self: *Compile, path: []const u8) void {
     const b = self.step.owner;
     self.include_dirs.append(IncludeDir{ .raw_path_system = b.dupe(path) }) catch @panic("OOM");
 }
-pub fn addIncludePath(self: *CompileStep, path: []const u8) void {
+pub fn addIncludePath(self: *Compile, path: []const u8) void {
     const b = self.step.owner;
     self.include_dirs.append(IncludeDir{ .raw_path = b.dupe(path) }) catch @panic("OOM");
 }
-pub fn addConfigHeader(self: *CompileStep, config_header: *ConfigHeaderStep) void {
+pub fn addConfigHeader(self: *Compile, config_header: *Step.ConfigHeader) void {
     self.step.dependOn(&config_header.step);
     self.include_dirs.append(.{ .config_header_step = config_header }) catch @panic("OOM");
 }
-pub fn addLibraryPath(self: *CompileStep, path: []const u8) void {
+pub fn addLibraryPath(self: *Compile, path: []const u8) void {
     const b = self.step.owner;
     self.lib_paths.append(.{ .path = b.dupe(path) }) catch @panic("OOM");
 }
-pub fn addLibraryPathDirectorySource(self: *CompileStep, directory_source: FileSource) void {
+pub fn addLibraryPathDirectorySource(self: *Compile, directory_source: FileSource) void {
     self.lib_paths.append(directory_source) catch @panic("OOM");
     directory_source.addStepDependencies(&self.step);
 }
-pub fn addRPath(self: *CompileStep, path: []const u8) void {
+pub fn addRPath(self: *Compile, path: []const u8) void {
     const b = self.step.owner;
     self.rpaths.append(.{ .path = b.dupe(path) }) catch @panic("OOM");
 }
-pub fn addRPathDirectorySource(self: *CompileStep, directory_source: FileSource) void {
+pub fn addRPathDirectorySource(self: *Compile, directory_source: FileSource) void {
     self.rpaths.append(directory_source) catch @panic("OOM");
     directory_source.addStepDependencies(&self.step);
 }
-pub fn addFrameworkPath(self: *CompileStep, dir_path: []const u8) void {
+pub fn addFrameworkPath(self: *Compile, dir_path: []const u8) void {
     const b = self.step.owner;
     self.framework_dirs.append(.{ .path = b.dupe(dir_path) }) catch @panic("OOM");
 }
-pub fn addFrameworkPathDirectorySource(self: *CompileStep, directory_source: FileSource) void {
+pub fn addFrameworkPathDirectorySource(self: *Compile, directory_source: FileSource) void {
     self.framework_dirs.append(directory_source) catch @panic("OOM");
     directory_source.addStepDependencies(&self.step);
 }
 /// Adds a module to be used with `@import` and exposing it in the current
 /// package's module table using `name`.
-pub fn addModule(cs: *CompileStep, name: []const u8, module: *Module) void {
+pub fn addModule(cs: *Compile, name: []const u8, module: *Module) void {
     const b = cs.step.owner;
     cs.modules.put(b.dupe(name), module) catch @panic("OOM");
 @@ -1025,17 +1019,17 @@ pub fn addModule(cs: *CompileStep, name: []const u8, module: *Module) void {
 /// Adds a module to be used with `@import` without exposing it in the current
 /// package's module table.
-pub fn addAnonymousModule(cs: *CompileStep, name: []const u8, options: std.Build.CreateModuleOptions) void {
+pub fn addAnonymousModule(cs: *Compile, name: []const u8, options: std.Build.CreateModuleOptions) void {
     const b = cs.step.owner;
     const module = b.createModule(options);
     return addModule(cs, name, module);
 }
-pub fn addOptions(cs: *CompileStep, module_name: []const u8, options: *OptionsStep) void {
+pub fn addOptions(cs: *Compile, module_name: []const u8, options: *Step.Options) void {
     addModule(cs, module_name, options.createModule());
 }
-fn addRecursiveBuildDeps(cs: *CompileStep, module: *Module, done: *std.AutoHashMap(*Module, void)) !void {
+fn addRecursiveBuildDeps(cs: *Compile, module: *Module, done: *std.AutoHashMap(*Module, void)) !void {
     if (done.contains(module)) return;
     try done.put(module, {});
     module.source_file.addStepDependencies(&cs.step);
 @@ -1046,7 +1040,7 @@ fn addRecursiveBuildDeps(cs: *CompileStep, module: *Module, done: *std.AutoHashM
 /// If Vcpkg was found on the system, it will be added to include and lib
 /// paths for the specified target.
-pub fn addVcpkgPaths(self: *CompileStep, linkage: CompileStep.Linkage) !void {
+pub fn addVcpkgPaths(self: *Compile, linkage: Compile.Linkage) !void {
     const b = self.step.owner;
     // Ideally in the Unattempted case we would call the function recursively
     // after findVcpkgRoot and have only one switch statement, but the compiler
 @@ -1082,7 +1076,7 @@ pub fn addVcpkgPaths(self: *CompileStep, linkage: CompileStep.Linkage) !void {
     }
 }
-pub fn setExecCmd(self: *CompileStep, args: []const ?[]const u8) void {
+pub fn setExecCmd(self: *Compile, args: []const ?[]const u8) void {
     const b = self.step.owner;
     assert(self.kind == .@"test");
     const duped_args = b.allocator.alloc(?[]u8, args.len) catch @panic("OOM");
 @@ -1092,7 +1086,7 @@ pub fn setExecCmd(self: *CompileStep, args: []const ?[]const u8) void {
     self.exec_cmd_args = duped_args;
 }
-fn linkLibraryOrObject(self: *CompileStep, other: *CompileStep) void {
+fn linkLibraryOrObject(self: *Compile, other: *Compile) void {
     self.step.dependOn(&other.step);
     self.link_objects.append(.{ .other_step = other }) catch @panic("OOM");
     self.include_dirs.append(.{ .other_step = other }) catch @panic("OOM");
 @@ -1103,7 +1097,7 @@ fn linkLibraryOrObject(self: *CompileStep, other: *CompileStep) void {
 }
 fn appendModuleArgs(
-    cs: *CompileStep,
+    cs: *Compile,
     zig_args: *ArrayList([]const u8),
 ) error{OutOfMemory}!void {
     const b = cs.step.owner;
 @@ -1214,7 +1208,7 @@ fn constructDepString(
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const b = step.owner;
-    const self = @fieldParentPtr(CompileStep, "step", step);
+    const self = @fieldParentPtr(Compile, "step", step);
     if (self.root_src == null and self.link_objects.items.len == 0) {
         return step.fail("the linker needs one or more objects to link", .{});
 @@ -2088,7 +2082,7 @@ const TransitiveDeps = struct {
         }
     }
-    fn addInner(td: *TransitiveDeps, other: *CompileStep, dyn: bool) !void {
+    fn addInner(td: *TransitiveDeps, other: *Compile, dyn: bool) !void {
         // Inherit dependency on libc and libc++
         td.is_linking_libcpp = td.is_linking_libcpp or other.is_linking_libcpp;
         td.is_linking_libc = td.is_linking_libc or other.is_linking_libc;
 @@ -2128,7 +2122,7 @@ const TransitiveDeps = struct {
     }
 };
-fn checkCompileErrors(self: *CompileStep) !void {
+fn checkCompileErrors(self: *Compile) !void {
     // Clear this field so that it does not get printed by the build runner.
     const actual_eb = self.step.result_error_bundle;
     self.step.result_error_bundle = std.zig.ErrorBundle.empty;

lib/std/Build/Step/ConfigHeader.zig+13-13

...	@@ -1,5 +1,5 @@	...	@@ -1,5 +1,5 @@
1	const std = @import("std");	1	const std = @import("std");
2	const ConfigHeaderStep = @This();	2	const ConfigHeader = @This();
3	const Step = std.Build.Step;	3	const Step = std.Build.Step;
4		4
5	pub const Style = union(enum) {	5	pub const Style = union(enum) {
...	@@ -48,8 +48,8 @@ pub const Options = struct {	...	@@ -48,8 +48,8 @@ pub const Options = struct {
48	first_ret_addr: ?usize = null,	48	first_ret_addr: ?usize = null,
49	};	49	};
50		50
51	pub fn create(owner: std.Build, options: Options) ConfigHeaderStep {	51	pub fn create(owner: std.Build, options: Options) ConfigHeader {
52	const self = owner.allocator.create(ConfigHeaderStep) catch @panic("OOM");	52	const self = owner.allocator.create(ConfigHeader) catch @panic("OOM");
53		53
54	var include_path: []const u8 = "config.h";	54	var include_path: []const u8 = "config.h";
55		55
...	@@ -93,21 +93,21 @@ pub fn create(owner: std.Build, options: Options) ConfigHeaderStep {	...	@@ -93,21 +93,21 @@ pub fn create(owner: std.Build, options: Options) ConfigHeaderStep {
93	return self;	93	return self;
94	}	94	}
95		95
96	pub fn addValues(self: *ConfigHeaderStep, values: anytype) void {	96	pub fn addValues(self: *ConfigHeader, values: anytype) void {
97	return addValuesInner(self, values) catch @panic("OOM");	97	return addValuesInner(self, values) catch @panic("OOM");
98	}	98	}
99		99
100	pub fn getFileSource(self: *ConfigHeaderStep) std.Build.FileSource {	100	pub fn getFileSource(self: *ConfigHeader) std.Build.FileSource {
101	return .{ .generated = &self.output_file };	101	return .{ .generated = &self.output_file };
102	}	102	}
103		103
104	fn addValuesInner(self: *ConfigHeaderStep, values: anytype) !void {	104	fn addValuesInner(self: *ConfigHeader, values: anytype) !void {
105	inline for (@typeInfo(@TypeOf(values)).Struct.fields) \|field\| {	105	inline for (@typeInfo(@TypeOf(values)).Struct.fields) \|field\| {
106	try putValue(self, field.name, field.type, @field(values, field.name));	106	try putValue(self, field.name, field.type, @field(values, field.name));
107	}	107	}
108	}	108	}
109		109
110	fn putValue(self: *ConfigHeaderStep, field_name: []const u8, comptime T: type, v: T) !void {	110	fn putValue(self: *ConfigHeader, field_name: []const u8, comptime T: type, v: T) !void {
111	switch (@typeInfo(T)) {	111	switch (@typeInfo(T)) {
112	.Null => {	112	.Null => {
113	try self.values.put(field_name, .undef);	113	try self.values.put(field_name, .undef);
...	@@ -151,31 +151,31 @@ fn putValue(self: *ConfigHeaderStep, field_name: []const u8, comptime T: type, v	...	@@ -151,31 +151,31 @@ fn putValue(self: *ConfigHeaderStep, field_name: []const u8, comptime T: type, v
151	else => {},	151	else => {},
152	}	152	}
153		153
154	@compileError("unsupported ConfigHeaderStep value type: " ++ @typeName(T));	154	@compileError("unsupported ConfigHeader value type: " ++ @typeName(T));
155	},	155	},
156	else => @compileError("unsupported ConfigHeaderStep value type: " ++ @typeName(T)),	156	else => @compileError("unsupported ConfigHeader value type: " ++ @typeName(T)),
157	}	157	}
158	}	158	}
159		159
160	fn make(step: Step, prog_node: std.Progress.Node) !void {	160	fn make(step: Step, prog_node: std.Progress.Node) !void {
161	_ = prog_node;	161	_ = prog_node;
162	const b = step.owner;	162	const b = step.owner;
163	const self = @fieldParentPtr(ConfigHeaderStep, "step", step);	163	const self = @fieldParentPtr(ConfigHeader, "step", step);
164	const gpa = b.allocator;	164	const gpa = b.allocator;
165	const arena = b.allocator;	165	const arena = b.allocator;
166		166
167	var man = b.cache.obtain();	167	var man = b.cache.obtain();
168	defer man.deinit();	168	defer man.deinit();
169		169
170	// Random bytes to make ConfigHeaderStep unique. Refresh this with new	170	// Random bytes to make ConfigHeader unique. Refresh this with new
171	// random bytes when ConfigHeaderStep implementation is modified in a	171	// random bytes when ConfigHeader implementation is modified in a
172	// non-backwards-compatible way.	172	// non-backwards-compatible way.
173	man.hash.add(@as(u32, 0xdef08d23));	173	man.hash.add(@as(u32, 0xdef08d23));
174		174
175	var output = std.ArrayList(u8).init(gpa);	175	var output = std.ArrayList(u8).init(gpa);
176	defer output.deinit();	176	defer output.deinit();
177		177
178	const header_text = "This file was generated by ConfigHeaderStep using the Zig Build System.";	178	const header_text = "This file was generated by ConfigHeader using the Zig Build System.";
179	const c_generated_line = "/* " ++ header_text ++ " */\n";	179	const c_generated_line = "/* " ++ header_text ++ " */\n";
180	const asm_generated_line = "; " ++ header_text ++ "\n";	180	const asm_generated_line = "; " ++ header_text ++ "\n";
181		181

lib/std/Build/Step/Fmt.zig+4-4

...	@@ -3,7 +3,7 @@	...	@@ -3,7 +3,7 @@
3	//! * Check mode: fail the step if a non-conforming file is found.	3	//! * Check mode: fail the step if a non-conforming file is found.
4	const std = @import("std");	4	const std = @import("std");
5	const Step = std.Build.Step;	5	const Step = std.Build.Step;
6	const FmtStep = @This();	6	const Fmt = @This();
7		7
8	step: Step,	8	step: Step,
9	paths: []const []const u8,	9	paths: []const []const u8,
...	@@ -19,8 +19,8 @@ pub const Options = struct {	...	@@ -19,8 +19,8 @@ pub const Options = struct {
19	check: bool = false,	19	check: bool = false,
20	};	20	};
21		21
22	pub fn create(owner: std.Build, options: Options) FmtStep {	22	pub fn create(owner: std.Build, options: Options) Fmt {
23	const self = owner.allocator.create(FmtStep) catch @panic("OOM");	23	const self = owner.allocator.create(Fmt) catch @panic("OOM");
24	const name = if (options.check) "zig fmt --check" else "zig fmt";	24	const name = if (options.check) "zig fmt --check" else "zig fmt";
25	self.* = .{	25	self.* = .{
26	.step = Step.init(.{	26	.step = Step.init(.{
...	@@ -47,7 +47,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -47,7 +47,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
47		47
48	const b = step.owner;	48	const b = step.owner;
49	const arena = b.allocator;	49	const arena = b.allocator;
50	const self = @fieldParentPtr(FmtStep, "step", step);	50	const self = @fieldParentPtr(Fmt, "step", step);
51		51
52	var argv: std.ArrayListUnmanaged([]const u8) = .{};	52	var argv: std.ArrayListUnmanaged([]const u8) = .{};
53	try argv.ensureUnusedCapacity(arena, 2 + 1 + self.paths.len + 2 * self.exclude_paths.len);	53	try argv.ensureUnusedCapacity(arena, 2 + 1 + self.paths.len + 2 * self.exclude_paths.len);

lib/std/Build/Step/InstallArtifact.zig+8-9

 @@ -1,24 +1,23 @@
 const std = @import("std");
 const Step = std.Build.Step;
-const CompileStep = std.Build.CompileStep;
 const InstallDir = std.Build.InstallDir;
-const InstallArtifactStep = @This();
+const InstallArtifact = @This();
 const fs = std.fs;
 pub const base_id = .install_artifact;
 step: Step,
-artifact: *CompileStep,
+artifact: *Step.Compile,
 dest_dir: InstallDir,
 pdb_dir: ?InstallDir,
 h_dir: ?InstallDir,
 /// If non-null, adds additional path components relative to dest_dir, and
-/// overrides the basename of the CompileStep.
+/// overrides the basename of the Compile step.
 dest_sub_path: ?[]const u8,
-pub fn create(owner: *std.Build, artifact: *CompileStep) *InstallArtifactStep {
+pub fn create(owner: *std.Build, artifact: *Step.Compile) *InstallArtifact {
-    const self = owner.allocator.create(InstallArtifactStep) catch @panic("OOM");
+    const self = owner.allocator.create(InstallArtifact) catch @panic("OOM");
-    self.* = InstallArtifactStep{
+    self.* = InstallArtifact{
         .step = Step.init(.{
             .id = base_id,
             .name = owner.fmt("install {s}", .{artifact.name}),
 @@ -66,7 +65,7 @@ pub fn create(owner: *std.Build, artifact: *CompileStep) *InstallArtifactStep {
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
-    const self = @fieldParentPtr(InstallArtifactStep, "step", step);
+    const self = @fieldParentPtr(InstallArtifact, "step", step);
     const src_builder = self.artifact.step.owner;
     const dest_builder = step.owner;
 @@ -90,7 +89,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         self.artifact.version != null and
         self.artifact.target.wantSharedLibSymLinks())
     {
-        try CompileStep.doAtomicSymLinks(step, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
+        try Step.Compile.doAtomicSymLinks(step, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
     }
     if (self.artifact.isDynamicLibrary() and
         self.artifact.target.isWindows() and

lib/std/Build/Step/InstallFile.zig+4-4

lib/std/Build/Step/ObjCopy.zig+8-9

 @@ -1,12 +1,11 @@
 const std = @import("std");
-const ObjCopyStep = @This();
+const ObjCopy = @This();
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
 const ArrayListUnmanaged = std.ArrayListUnmanaged;
 const File = std.fs.File;
 const InstallDir = std.Build.InstallDir;
-const CompileStep = std.Build.CompileStep;
 const Step = std.Build.Step;
 const elf = std.elf;
 const fs = std.fs;
 @@ -40,9 +39,9 @@ pub fn create(
     owner: *std.Build,
     file_source: std.Build.FileSource,
     options: Options,
-) *ObjCopyStep {
+) *ObjCopy {
-    const self = owner.allocator.create(ObjCopyStep) catch @panic("OOM");
+    const self = owner.allocator.create(ObjCopy) catch @panic("OOM");
-    self.* = ObjCopyStep{
+    self.* = ObjCopy{
         .step = Step.init(.{
             .id = base_id,
             .name = owner.fmt("objcopy {s}", .{file_source.getDisplayName()}),
 @@ -61,19 +60,19 @@ pub fn create(
     return self;
 }
-pub fn getOutputSource(self: *const ObjCopyStep) std.Build.FileSource {
+pub fn getOutputSource(self: *const ObjCopy) std.Build.FileSource {
     return .{ .generated = &self.output_file };
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const b = step.owner;
-    const self = @fieldParentPtr(ObjCopyStep, "step", step);
+    const self = @fieldParentPtr(ObjCopy, "step", step);
     var man = b.cache.obtain();
     defer man.deinit();
-    // Random bytes to make ObjCopyStep unique. Refresh this with new random
+    // Random bytes to make ObjCopy unique. Refresh this with new random
-    // bytes when ObjCopyStep implementation is modified incompatibly.
+    // bytes when ObjCopy implementation is modified incompatibly.
     man.hash.add(@as(u32, 0xe18b7baf));
     const full_src_path = self.file_source.getPath(b);

lib/std/Build/Step/Options.zig+12-13

 @@ -3,10 +3,9 @@ const builtin = @import("builtin");
 const fs = std.fs;
 const Step = std.Build.Step;
 const GeneratedFile = std.Build.GeneratedFile;
-const CompileStep = std.Build.CompileStep;
 const FileSource = std.Build.FileSource;
-const OptionsStep = @This();
+const Options = @This();
 pub const base_id = .options;
 @@ -17,8 +16,8 @@ contents: std.ArrayList(u8),
 artifact_args: std.ArrayList(OptionArtifactArg),
 file_source_args: std.ArrayList(OptionFileSourceArg),
-pub fn create(owner: *std.Build) *OptionsStep {
+pub fn create(owner: *std.Build) *Options {
-    const self = owner.allocator.create(OptionsStep) catch @panic("OOM");
+    const self = owner.allocator.create(Options) catch @panic("OOM");
     self.* = .{
         .step = Step.init(.{
             .id = base_id,
 @@ -36,11 +35,11 @@ pub fn create(owner: *std.Build) *OptionsStep {
     return self;
 }
-pub fn addOption(self: *OptionsStep, comptime T: type, name: []const u8, value: T) void {
+pub fn addOption(self: *Options, comptime T: type, name: []const u8, value: T) void {
     return addOptionFallible(self, T, name, value) catch @panic("unhandled error");
 }
-fn addOptionFallible(self: *OptionsStep, comptime T: type, name: []const u8, value: T) !void {
+fn addOptionFallible(self: *Options, comptime T: type, name: []const u8, value: T) !void {
     const out = self.contents.writer();
     switch (T) {
         []const []const u8 => {
 @@ -189,7 +188,7 @@ fn printLiteral(out: anytype, val: anytype, indent: u8) !void {
 /// The value is the path in the cache dir.
 /// Adds a dependency automatically.
 pub fn addOptionFileSource(
-    self: *OptionsStep,
+    self: *Options,
     name: []const u8,
     source: FileSource,
 ) void {
 @@ -202,19 +201,19 @@ pub fn addOptionFileSource(
 /// The value is the path in the cache dir.
 /// Adds a dependency automatically.
-pub fn addOptionArtifact(self: *OptionsStep, name: []const u8, artifact: *CompileStep) void {
+pub fn addOptionArtifact(self: *Options, name: []const u8, artifact: *Step.Compile) void {
     self.artifact_args.append(.{ .name = self.step.owner.dupe(name), .artifact = artifact }) catch @panic("OOM");
     self.step.dependOn(&artifact.step);
 }
-pub fn createModule(self: *OptionsStep) *std.Build.Module {
+pub fn createModule(self: *Options) *std.Build.Module {
     return self.step.owner.createModule(.{
         .source_file = self.getSource(),
         .dependencies = &.{},
     });
 }
-pub fn getSource(self: *OptionsStep) FileSource {
+pub fn getSource(self: *Options) FileSource {
     return .{ .generated = &self.generated_file };
 }
 @@ -223,7 +222,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
     const b = step.owner;
-    const self = @fieldParentPtr(OptionsStep, "step", step);
+    const self = @fieldParentPtr(Options, "step", step);
     for (self.artifact_args.items) |item| {
         self.addOption(
 @@ -314,7 +313,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
 const OptionArtifactArg = struct {
     name: []const u8,
-    artifact: *CompileStep,
+    artifact: *Step.Compile,
 };
 const OptionFileSourceArg = struct {
 @@ -322,7 +321,7 @@ const OptionFileSourceArg = struct {
     source: FileSource,
 };
-test "OptionsStep" {
+test Options {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);

lib/std/Build/Step/RemoveDir.zig+4-4

...	@@ -1,15 +1,15 @@	...	@@ -1,15 +1,15 @@
1	const std = @import("std");	1	const std = @import("std");
2	const fs = std.fs;	2	const fs = std.fs;
3	const Step = std.Build.Step;	3	const Step = std.Build.Step;
4	const RemoveDirStep = @This();	4	const RemoveDir = @This();
5		5
6	pub const base_id = .remove_dir;	6	pub const base_id = .remove_dir;
7		7
8	step: Step,	8	step: Step,
9	dir_path: []const u8,	9	dir_path: []const u8,
10		10
11	pub fn init(owner: *std.Build, dir_path: []const u8) RemoveDirStep {	11	pub fn init(owner: *std.Build, dir_path: []const u8) RemoveDir {
12	return RemoveDirStep{	12	return RemoveDir{
13	.step = Step.init(.{	13	.step = Step.init(.{
14	.id = .remove_dir,	14	.id = .remove_dir,
15	.name = owner.fmt("RemoveDir {s}", .{dir_path}),	15	.name = owner.fmt("RemoveDir {s}", .{dir_path}),
...	@@ -26,7 +26,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -26,7 +26,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
26	_ = prog_node;	26	_ = prog_node;
27		27
28	const b = step.owner;	28	const b = step.owner;
29	const self = @fieldParentPtr(RemoveDirStep, "step", step);	29	const self = @fieldParentPtr(RemoveDir, "step", step);
30		30
31	b.build_root.handle.deleteTree(self.dir_path) catch \|err\| {	31	b.build_root.handle.deleteTree(self.dir_path) catch \|err\| {
32	if (b.build_root.path) \|base\| {	32	if (b.build_root.path) \|base\| {

lib/std/Build/Step/Run.zig+53-55

 @@ -1,8 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const Step = std.Build.Step;
-const CompileStep = std.Build.CompileStep;
-const WriteFileStep = std.Build.WriteFileStep;
 const fs = std.fs;
 const mem = std.mem;
 const process = std.process;
 @@ -12,7 +10,7 @@ const Allocator = mem.Allocator;
 const ExecError = std.Build.ExecError;
 const assert = std.debug.assert;
-const RunStep = @This();
+const Run = @This();
 pub const base_id: Step.Id = .run;
 @@ -29,12 +27,12 @@ cwd: ?[]const u8,
 /// Override this field to modify the environment, or use setEnvironmentVariable
 env_map: ?*EnvMap,
-/// Configures whether the RunStep is considered to have side-effects, and also
+/// Configures whether the Run step is considered to have side-effects, and also
-/// whether the RunStep will inherit stdio streams, forwarding them to the
+/// whether the Run step will inherit stdio streams, forwarding them to the
 /// parent process, in which case will require a global lock to prevent other
 /// steps from interfering with stdio while the subprocess associated with this
-/// RunStep is running.
+/// Run step is running.
-/// If the RunStep is determined to not have side-effects, then execution will
+/// If the Run step is determined to not have side-effects, then execution will
 /// be skipped if all output files are up-to-date and input files are
 /// unchanged.
 stdio: StdIo = .infer_from_args,
 @@ -42,9 +40,9 @@ stdio: StdIo = .infer_from_args,
 stdin: ?[]const u8 = null,
 /// Additional file paths relative to build.zig that, when modified, indicate
-/// that the RunStep should be re-executed.
+/// that the Run step should be re-executed.
-/// If the RunStep is determined to have side-effects, this field is ignored
+/// If the Run step is determined to have side-effects, this field is ignored
-/// and the RunStep is always executed when it appears in the build graph.
+/// and the Run step is always executed when it appears in the build graph.
 extra_file_dependencies: []const []const u8 = &.{},
 /// After adding an output argument, this step will by default rename itself
 @@ -52,14 +50,14 @@ extra_file_dependencies: []const []const u8 = &.{},
 /// This can be disabled by setting this to false.
 rename_step_with_output_arg: bool = true,
-/// If this is true, a RunStep which is configured to check the output of the
+/// If this is true, a Run step which is configured to check the output of the
 /// executed binary will not fail the build if the binary cannot be executed
 /// due to being for a foreign binary to the host system which is running the
 /// build graph.
 /// Command-line arguments such as -fqemu and -fwasmtime may affect whether a
 /// binary is detected as foreign, as well as system configuration such as
 /// Rosetta (macOS) and binfmt_misc (Linux).
-/// If this RunStep is considered to have side-effects, then this flag does
+/// If this Run step is considered to have side-effects, then this flag does
 /// nothing.
 skip_foreign_checks: bool = false,
 @@ -73,18 +71,18 @@ captured_stderr: ?*Output = null,
 has_side_effects: bool = false,
 pub const StdIo = union(enum) {
-    /// Whether the RunStep has side-effects will be determined by whether or not one
+    /// Whether the Run step has side-effects will be determined by whether or not one
     /// of the args is an output file (added with `addOutputFileArg`).
-    /// If the RunStep is determined to have side-effects, this is the same as `inherit`.
+    /// If the Run step is determined to have side-effects, this is the same as `inherit`.
     /// The step will fail if the subprocess crashes or returns a non-zero exit code.
     infer_from_args,
-    /// Causes the RunStep to be considered to have side-effects, and therefore
+    /// Causes the Run step to be considered to have side-effects, and therefore
     /// always execute when it appears in the build graph.
     /// It also means that this step will obtain a global lock to prevent other
     /// steps from running in the meantime.
     /// The step will fail if the subprocess crashes or returns a non-zero exit code.
     inherit,
-    /// Causes the RunStep to be considered to *not* have side-effects. The
+    /// Causes the Run step to be considered to *not* have side-effects. The
     /// process will be re-executed if any of the input dependencies are
     /// modified. The exit code and standard I/O streams will be checked for
     /// certain conditions, and the step will succeed or fail based on these
 @@ -92,7 +90,7 @@ pub const StdIo = union(enum) {
     /// Note that an explicit check for exit code 0 needs to be added to this
     /// list if such a check is desirable.
     check: std.ArrayList(Check),
-    /// This RunStep is running a zig unit test binary and will communicate
+    /// This Run step is running a zig unit test binary and will communicate
     /// extra metadata over the IPC protocol.
     zig_test,
 @@ -106,7 +104,7 @@ pub const StdIo = union(enum) {
 };
 pub const Arg = union(enum) {
-    artifact: *CompileStep,
+    artifact: *Step.Compile,
     file_source: std.Build.FileSource,
     directory_source: std.Build.FileSource,
     bytes: []u8,
 @@ -119,8 +117,8 @@ pub const Output = struct {
     basename: []const u8,
 };
-pub fn create(owner: *std.Build, name: []const u8) *RunStep {
+pub fn create(owner: *std.Build, name: []const u8) *Run {
-    const self = owner.allocator.create(RunStep) catch @panic("OOM");
+    const self = owner.allocator.create(Run) catch @panic("OOM");
     self.* = .{
         .step = Step.init(.{
             .id = base_id,
 @@ -135,17 +133,17 @@ pub fn create(owner: *std.Build, name: []const u8) *RunStep {
     return self;
 }
-pub fn setName(self: *RunStep, name: []const u8) void {
+pub fn setName(self: *Run, name: []const u8) void {
     self.step.name = name;
     self.rename_step_with_output_arg = false;
 }
-pub fn enableTestRunnerMode(rs: *RunStep) void {
+pub fn enableTestRunnerMode(rs: *Run) void {
     rs.stdio = .zig_test;
     rs.addArgs(&.{"--listen=-"});
 }
-pub fn addArtifactArg(self: *RunStep, artifact: *CompileStep) void {
+pub fn addArtifactArg(self: *Run, artifact: *Step.Compile) void {
     self.argv.append(Arg{ .artifact = artifact }) catch @panic("OOM");
     self.step.dependOn(&artifact.step);
 }
 @@ -153,12 +151,12 @@ pub fn addArtifactArg(self: *RunStep, artifact: *CompileStep) void {
 /// This provides file path as a command line argument to the command being
 /// run, and returns a FileSource which can be used as inputs to other APIs
 /// throughout the build system.
-pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource {
+pub fn addOutputFileArg(rs: *Run, basename: []const u8) std.Build.FileSource {
     return addPrefixedOutputFileArg(rs, "", basename);
 }
 pub fn addPrefixedOutputFileArg(
-    rs: *RunStep,
+    rs: *Run,
     prefix: []const u8,
     basename: []const u8,
 ) std.Build.FileSource {
 @@ -179,38 +177,38 @@ pub fn addPrefixedOutputFileArg(
     return .{ .generated = &output.generated_file };
 }
-pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {
+pub fn addFileSourceArg(self: *Run, file_source: std.Build.FileSource) void {
     self.argv.append(.{
         .file_source = file_source.dupe(self.step.owner),
     }) catch @panic("OOM");
     file_source.addStepDependencies(&self.step);
 }
-pub fn addDirectorySourceArg(self: *RunStep, directory_source: std.Build.FileSource) void {
+pub fn addDirectorySourceArg(self: *Run, directory_source: std.Build.FileSource) void {
     self.argv.append(.{
         .directory_source = directory_source.dupe(self.step.owner),
     }) catch @panic("OOM");
     directory_source.addStepDependencies(&self.step);
 }
-pub fn addArg(self: *RunStep, arg: []const u8) void {
+pub fn addArg(self: *Run, arg: []const u8) void {
     self.argv.append(.{ .bytes = self.step.owner.dupe(arg) }) catch @panic("OOM");
 }
-pub fn addArgs(self: *RunStep, args: []const []const u8) void {
+pub fn addArgs(self: *Run, args: []const []const u8) void {
     for (args) |arg| {
         self.addArg(arg);
     }
 }
-pub fn clearEnvironment(self: *RunStep) void {
+pub fn clearEnvironment(self: *Run) void {
     const b = self.step.owner;
     const new_env_map = b.allocator.create(EnvMap) catch @panic("OOM");
     new_env_map.* = EnvMap.init(b.allocator);
     self.env_map = new_env_map;
 }
-pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
+pub fn addPathDir(self: *Run, search_path: []const u8) void {
     const b = self.step.owner;
     const env_map = getEnvMapInternal(self);
 @@ -225,11 +223,11 @@ pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
     }
 }
-pub fn getEnvMap(self: *RunStep) *EnvMap {
+pub fn getEnvMap(self: *Run) *EnvMap {
     return getEnvMapInternal(self);
 }
-fn getEnvMapInternal(self: *RunStep) *EnvMap {
+fn getEnvMapInternal(self: *Run) *EnvMap {
     const arena = self.step.owner.allocator;
     return self.env_map orelse {
         const env_map = arena.create(EnvMap) catch @panic("OOM");
 @@ -239,25 +237,25 @@ fn getEnvMapInternal(self: *RunStep) *EnvMap {
     };
 }
-pub fn setEnvironmentVariable(self: *RunStep, key: []const u8, value: []const u8) void {
+pub fn setEnvironmentVariable(self: *Run, key: []const u8, value: []const u8) void {
     const b = self.step.owner;
     const env_map = self.getEnvMap();
     env_map.put(b.dupe(key), b.dupe(value)) catch @panic("unhandled error");
 }
-pub fn removeEnvironmentVariable(self: *RunStep, key: []const u8) void {
+pub fn removeEnvironmentVariable(self: *Run, key: []const u8) void {
     self.getEnvMap().remove(key);
 }
 /// Adds a check for exact stderr match. Does not add any other checks.
-pub fn expectStdErrEqual(self: *RunStep, bytes: []const u8) void {
+pub fn expectStdErrEqual(self: *Run, bytes: []const u8) void {
     const new_check: StdIo.Check = .{ .expect_stderr_exact = self.step.owner.dupe(bytes) };
     self.addCheck(new_check);
 }
 /// Adds a check for exact stdout match as well as a check for exit code 0, if
 /// there is not already an expected termination check.
-pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void {
+pub fn expectStdOutEqual(self: *Run, bytes: []const u8) void {
     const new_check: StdIo.Check = .{ .expect_stdout_exact = self.step.owner.dupe(bytes) };
     self.addCheck(new_check);
     if (!self.hasTermCheck()) {
 @@ -265,12 +263,12 @@ pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void {
     }
 }
-pub fn expectExitCode(self: *RunStep, code: u8) void {
+pub fn expectExitCode(self: *Run, code: u8) void {
     const new_check: StdIo.Check = .{ .expect_term = .{ .Exited = code } };
     self.addCheck(new_check);
 }
-pub fn hasTermCheck(self: RunStep) bool {
+pub fn hasTermCheck(self: Run) bool {
     for (self.stdio.check.items) |check| switch (check) {
         .expect_term => return true,
         else => continue,
 @@ -278,18 +276,18 @@ pub fn hasTermCheck(self: RunStep) bool {
     return false;
 }
-pub fn addCheck(self: *RunStep, new_check: StdIo.Check) void {
+pub fn addCheck(self: *Run, new_check: StdIo.Check) void {
     switch (self.stdio) {
         .infer_from_args => {
             self.stdio = .{ .check = std.ArrayList(StdIo.Check).init(self.step.owner.allocator) };
             self.stdio.check.append(new_check) catch @panic("OOM");
         },
         .check => |*checks| checks.append(new_check) catch @panic("OOM"),
-        else => @panic("illegal call to addCheck: conflicting helper method calls. Suggest to directly set stdio field of RunStep instead"),
+        else => @panic("illegal call to addCheck: conflicting helper method calls. Suggest to directly set stdio field of Run instead"),
     }
 }
-pub fn captureStdErr(self: *RunStep) std.Build.FileSource {
+pub fn captureStdErr(self: *Run) std.Build.FileSource {
     assert(self.stdio != .inherit);
     if (self.captured_stderr) |output| return .{ .generated = &output.generated_file };
 @@ -304,7 +302,7 @@ pub fn captureStdErr(self: *RunStep) std.Build.FileSource {
     return .{ .generated = &output.generated_file };
 }
-pub fn captureStdOut(self: *RunStep) std.Build.FileSource {
+pub fn captureStdOut(self: *Run) std.Build.FileSource {
     assert(self.stdio != .inherit);
     if (self.captured_stdout) |output| return .{ .generated = &output.generated_file };
 @@ -319,8 +317,8 @@ pub fn captureStdOut(self: *RunStep) std.Build.FileSource {
     return .{ .generated = &output.generated_file };
 }
-/// Returns whether the RunStep has side effects *other than* updating the output arguments.
+/// Returns whether the Run step has side effects *other than* updating the output arguments.
-fn hasSideEffects(self: RunStep) bool {
+fn hasSideEffects(self: Run) bool {
     if (self.has_side_effects) return true;
     return switch (self.stdio) {
         .infer_from_args => !self.hasAnyOutputArgs(),
 @@ -330,7 +328,7 @@ fn hasSideEffects(self: RunStep) bool {
     };
 }
-fn hasAnyOutputArgs(self: RunStep) bool {
+fn hasAnyOutputArgs(self: Run) bool {
     if (self.captured_stdout != null) return true;
     if (self.captured_stderr != null) return true;
     for (self.argv.items) |arg| switch (arg) {
 @@ -371,7 +369,7 @@ fn checksContainStderr(checks: []const StdIo.Check) bool {
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const b = step.owner;
     const arena = b.allocator;
-    const self = @fieldParentPtr(RunStep, "step", step);
+    const self = @fieldParentPtr(Run, "step", step);
     const has_side_effects = self.hasSideEffects();
     var argv_list = ArrayList([]const u8).init(arena);
 @@ -541,7 +539,7 @@ fn termMatches(expected: ?std.process.Child.Term, actual: std.process.Child.Term
 }
 fn runCommand(
-    self: *RunStep,
+    self: *Run,
     argv: []const []const u8,
     has_side_effects: bool,
     digest: ?*const [std.Build.Cache.hex_digest_len]u8,
 @@ -567,7 +565,7 @@ fn runCommand(
         // FileNotFound: can happen with a wrong dynamic linker path
         if (err == error.InvalidExe or err == error.FileNotFound) interpret: {
             // TODO: learn the target from the binary directly rather than from
-            // relying on it being a CompileStep. This will make this logic
+            // relying on it being a Compile step. This will make this logic
             // work even for the edge case that the binary was produced by a
             // third party.
             const exe = switch (self.argv.items[0]) {
 @@ -862,7 +860,7 @@ const ChildProcResult = struct {
 };
 fn spawnChildAndCollect(
-    self: *RunStep,
+    self: *Run,
     argv: []const []const u8,
     has_side_effects: bool,
     prog_node: *std.Progress.Node,
 @@ -936,7 +934,7 @@ const StdIoResult = struct {
 };
 fn evalZigTest(
-    self: *RunStep,
+    self: *Run,
     child: *std.process.Child,
     prog_node: *std.Progress.Node,
 ) !StdIoResult {
 @@ -1121,7 +1119,7 @@ fn sendRunTestMessage(file: std.fs.File, index: u32) !void {
     try file.writeAll(full_msg);
 }
-fn evalGeneric(self: *RunStep, child: *std.process.Child) !StdIoResult {
+fn evalGeneric(self: *Run, child: *std.process.Child) !StdIoResult {
     const arena = self.step.owner.allocator;
     if (self.stdin) |stdin| {
 @@ -1188,7 +1186,7 @@ fn evalGeneric(self: *RunStep, child: *std.process.Child) !StdIoResult {
     };
 }
-fn addPathForDynLibs(self: *RunStep, artifact: *CompileStep) void {
+fn addPathForDynLibs(self: *Run, artifact: *Step.Compile) void {
     const b = self.step.owner;
     for (artifact.link_objects.items) |link_object| {
         switch (link_object) {
 @@ -1204,10 +1202,10 @@ fn addPathForDynLibs(self: *RunStep, artifact: *CompileStep) void {
 }
 fn failForeign(
-    self: *RunStep,
+    self: *Run,
     suggested_flag: []const u8,
     argv0: []const u8,
-    exe: *CompileStep,
+    exe: *Step.Compile,
 ) error{ MakeFailed, MakeSkipped, OutOfMemory } {
     switch (self.stdio) {
         .check, .zig_test => {

lib/std/Build/Step/TranslateC.zig+12-14

 @@ -1,12 +1,10 @@
 const std = @import("std");
 const Step = std.Build.Step;
-const CompileStep = std.Build.CompileStep;
-const CheckFileStep = std.Build.CheckFileStep;
 const fs = std.fs;
 const mem = std.mem;
 const CrossTarget = std.zig.CrossTarget;
-const TranslateCStep = @This();
+const TranslateC = @This();
 pub const base_id = .translate_c;
 @@ -25,10 +23,10 @@ pub const Options = struct {
     optimize: std.builtin.OptimizeMode,
 };
-pub fn create(owner: *std.Build, options: Options) *TranslateCStep {
+pub fn create(owner: *std.Build, options: Options) *TranslateC {
-    const self = owner.allocator.create(TranslateCStep) catch @panic("OOM");
+    const self = owner.allocator.create(TranslateC) catch @panic("OOM");
     const source = options.source_file.dupe(owner);
-    self.* = TranslateCStep{
+    self.* = TranslateC{
         .step = Step.init(.{
             .id = .translate_c,
             .name = "translate-c",
 @@ -52,11 +50,11 @@ pub const AddExecutableOptions = struct {
     version: ?std.builtin.Version = null,
     target: ?CrossTarget = null,
     optimize: ?std.builtin.Mode = null,
-    linkage: ?CompileStep.Linkage = null,
+    linkage: ?Step.Compile.Linkage = null,
 };
 /// Creates a step to build an executable from the translated source.
-pub fn addExecutable(self: *TranslateCStep, options: AddExecutableOptions) *CompileStep {
+pub fn addExecutable(self: *TranslateC, options: AddExecutableOptions) *Step.Compile {
     return self.step.owner.addExecutable(.{
         .root_source_file = .{ .generated = &self.output_file },
         .name = options.name orelse "translated_c",
 @@ -67,12 +65,12 @@ pub fn addExecutable(self: *TranslateCStep, options: AddExecutableOptions) *Comp
     });
 }
-pub fn addIncludeDir(self: *TranslateCStep, include_dir: []const u8) void {
+pub fn addIncludeDir(self: *TranslateC, include_dir: []const u8) void {
     self.include_dirs.append(self.step.owner.dupePath(include_dir)) catch @panic("OOM");
 }
-pub fn addCheckFile(self: *TranslateCStep, expected_matches: []const []const u8) *CheckFileStep {
+pub fn addCheckFile(self: *TranslateC, expected_matches: []const []const u8) *Step.CheckFile {
-    return CheckFileStep.create(
+    return Step.CheckFile.create(
         self.step.owner,
         .{ .generated = &self.output_file },
         .{ .expected_matches = expected_matches },
 @@ -81,19 +79,19 @@ pub fn addCheckFile(self: *TranslateCStep, expected_matches: []const []const u8)
 /// If the value is omitted, it is set to 1.
 /// `name` and `value` need not live longer than the function call.
-pub fn defineCMacro(self: *TranslateCStep, name: []const u8, value: ?[]const u8) void {
+pub fn defineCMacro(self: *TranslateC, name: []const u8, value: ?[]const u8) void {
     const macro = std.Build.constructCMacro(self.step.owner.allocator, name, value);
     self.c_macros.append(macro) catch @panic("OOM");
 }
 /// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.
-pub fn defineCMacroRaw(self: *TranslateCStep, name_and_value: []const u8) void {
+pub fn defineCMacroRaw(self: *TranslateC, name_and_value: []const u8) void {
     self.c_macros.append(self.step.owner.dupe(name_and_value)) catch @panic("OOM");
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const b = step.owner;
-    const self = @fieldParentPtr(TranslateCStep, "step", step);
+    const self = @fieldParentPtr(TranslateC, "step", step);
     var argv_list = std.ArrayList([]const u8).init(b.allocator);
     try argv_list.append(b.zig_exe);

lib/std/Build/Step/WriteFile.zig+19-19

test/link/macho/dead_strip/build.zig+1-1

...	@@ -42,7 +42,7 @@ fn createScenario(	...	@@ -42,7 +42,7 @@ fn createScenario(
42	optimize: std.builtin.OptimizeMode,	42	optimize: std.builtin.OptimizeMode,
43	target: std.zig.CrossTarget,	43	target: std.zig.CrossTarget,
44	name: []const u8,	44	name: []const u8,
45	) *std.Build.CompileStep {	45	) *std.Build.Step.Compile {
46	const exe = b.addExecutable(.{	46	const exe = b.addExecutable(.{
47	.name = name,	47	.name = name,
48	.optimize = optimize,	48	.optimize = optimize,

test/link/macho/dead_strip_dylibs/build.zig+1-1

...	@@ -46,7 +46,7 @@ fn createScenario(	...	@@ -46,7 +46,7 @@ fn createScenario(
46	b: *std.Build,	46	b: *std.Build,
47	optimize: std.builtin.OptimizeMode,	47	optimize: std.builtin.OptimizeMode,
48	name: []const u8,	48	name: []const u8,
49	) *std.Build.CompileStep {	49	) *std.Build.Step.Compile {
50	const exe = b.addExecutable(.{	50	const exe = b.addExecutable(.{
51	.name = name,	51	.name = name,
52	.optimize = optimize,	52	.optimize = optimize,

test/link/macho/headerpad/build.zig+1-1

...	@@ -104,7 +104,7 @@ fn simpleExe(	...	@@ -104,7 +104,7 @@ fn simpleExe(
104	b: *std.Build,	104	b: *std.Build,
105	optimize: std.builtin.OptimizeMode,	105	optimize: std.builtin.OptimizeMode,
106	name: []const u8,	106	name: []const u8,
107	) *std.Build.CompileStep {	107	) *std.Build.Step.Compile {
108	const exe = b.addExecutable(.{	108	const exe = b.addExecutable(.{
109	.name = name,	109	.name = name,
110	.optimize = optimize,	110	.optimize = optimize,

test/link/macho/search_strategy/build.zig+1-1

...	@@ -46,7 +46,7 @@ fn createScenario(	...	@@ -46,7 +46,7 @@ fn createScenario(
46	optimize: std.builtin.OptimizeMode,	46	optimize: std.builtin.OptimizeMode,
47	target: std.zig.CrossTarget,	47	target: std.zig.CrossTarget,
48	name: []const u8,	48	name: []const u8,
49	) *std.Build.CompileStep {	49	) *std.Build.Step.Compile {
50	const static = b.addStaticLibrary(.{	50	const static = b.addStaticLibrary(.{
51	.name = name,	51	.name = name,
52	.optimize = optimize,	52	.optimize = optimize,

test/link/macho/unwind_info/build.zig+1-1

...	@@ -65,7 +65,7 @@ fn createScenario(	...	@@ -65,7 +65,7 @@ fn createScenario(
65	optimize: std.builtin.OptimizeMode,	65	optimize: std.builtin.OptimizeMode,
66	target: std.zig.CrossTarget,	66	target: std.zig.CrossTarget,
67	name: []const u8,	67	name: []const u8,
68	) *std.Build.CompileStep {	68	) *std.Build.Step.Compile {
69	const exe = b.addExecutable(.{	69	const exe = b.addExecutable(.{
70	.name = name,	70	.name = name,
71	.optimize = optimize,	71	.optimize = optimize,

test/link/macho/uuid/build.zig+1-2

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	const std = @import("std");	1	const std = @import("std");
2	const CompileStep = std.Build.CompileStep;
3	const FileSource = std.Build.FileSource;	2	const FileSource = std.Build.FileSource;
4	const Step = std.Build.Step;	3	const Step = std.Build.Step;
5		4
...	@@ -60,7 +59,7 @@ fn simpleDylib(	...	@@ -60,7 +59,7 @@ fn simpleDylib(
60	b: *std.Build,	59	b: *std.Build,
61	optimize: std.builtin.OptimizeMode,	60	optimize: std.builtin.OptimizeMode,
62	target: std.zig.CrossTarget,	61	target: std.zig.CrossTarget,
63	) *std.Build.CompileStep {	62	) *std.Build.Step.Compile {
64	const dylib = b.addSharedLibrary(.{	63	const dylib = b.addSharedLibrary(.{
65	.name = "test",	64	.name = "test",
66	.version = .{ .major = 1, .minor = 0 },	65	.version = .{ .major = 1, .minor = 0 },

test/src/Cases.zig+1-1

...	@@ -465,7 +465,7 @@ pub fn lowerToBuildSteps(	...	@@ -465,7 +465,7 @@ pub fn lowerToBuildSteps(
465	parent_step: *std.Build.Step,	465	parent_step: *std.Build.Step,
466	opt_test_filter: ?[]const u8,	466	opt_test_filter: ?[]const u8,
467	cases_dir_path: []const u8,	467	cases_dir_path: []const u8,
468	incremental_exe: *std.Build.CompileStep,	468	incremental_exe: *std.Build.Step.Compile,
469	) void {	469	) void {
470	for (self.incremental_cases.items) \|incr_case\| {	470	for (self.incremental_cases.items) \|incr_case\| {
471	if (opt_test_filter) \|test_filter\| {	471	if (opt_test_filter) \|test_filter\| {

test/src/StackTrace.zig+1-1

...	@@ -3,7 +3,7 @@ step: *Step,	...	@@ -3,7 +3,7 @@ step: *Step,
3	test_index: usize,	3	test_index: usize,
4	test_filter: ?[]const u8,	4	test_filter: ?[]const u8,
5	optimize_modes: []const OptimizeMode,	5	optimize_modes: []const OptimizeMode,
6	check_exe: *std.Build.CompileStep,	6	check_exe: *std.Build.Step.Compile,
7		7
8	const Expect = [@typeInfo(OptimizeMode).Enum.fields.len][]const u8;	8	const Expect = [@typeInfo(OptimizeMode).Enum.fields.len][]const u8;
9		9

test/standalone/install_raw_hex/build.zig-1

...	@@ -1,6 +1,5 @@	...	@@ -1,6 +1,5 @@
1	const builtin = @import("builtin");	1	const builtin = @import("builtin");
2	const std = @import("std");	2	const std = @import("std");
3	const CheckFileStep = std.Build.CheckFileStep;
4		3
5	pub fn build(b: *std.Build) void {	4	pub fn build(b: *std.Build) void {
6	const test_step = b.step("test", "Test it");	5	const test_step = b.step("test", "Test it");

test/tests.zig+1-1

...	@@ -1132,7 +1132,7 @@ pub fn addCases(	...	@@ -1132,7 +1132,7 @@ pub fn addCases(
1132	b: *std.Build,	1132	b: *std.Build,
1133	parent_step: *Step,	1133	parent_step: *Step,
1134	opt_test_filter: ?[]const u8,	1134	opt_test_filter: ?[]const u8,
1135	check_case_exe: *std.Build.CompileStep,	1135	check_case_exe: *std.Build.Step.Compile,
1136	) !void {	1136	) !void {
1137	const arena = b.allocator;	1137	const arena = b.allocator;
1138	const gpa = b.allocator;	1138	const gpa = b.allocator;

author	Veikka Tuominen <git@vexu.eu> 2023-05-03 11:49:55+03:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-05-03 20:55:29-07:00
log	3f3b1a6808113fd5f9b2cec1033009cbb17dc969
tree	7893be58b9b8c8edfffdc8127a6b133ec823e141
parent	5def162391da5050761beb3e6efb24b99716fc99

...	@@ -6,7 +6,7 @@ const math = std.math;	...	@@ -6,7 +6,7 @@ const math = std.math;
6	const mem = std.mem;	6	const mem = std.mem;
7	const testing = std.testing;	7	const testing = std.testing;
8		8
9	const CheckObjectStep = @This();	9	const CheckObject = @This();
10		10
11	const Allocator = mem.Allocator;	11	const Allocator = mem.Allocator;
12	const Step = std.Build.Step;	12	const Step = std.Build.Step;
...	@@ -24,9 +24,9 @@ pub fn create(	...	@@ -24,9 +24,9 @@ pub fn create(
24	owner: *std.Build,	24	owner: *std.Build,
25	source: std.Build.FileSource,	25	source: std.Build.FileSource,
26	obj_format: std.Target.ObjectFormat,	26	obj_format: std.Target.ObjectFormat,
27	) *CheckObjectStep {	27	) *CheckObject {
28	const gpa = owner.allocator;	28	const gpa = owner.allocator;
29	const self = gpa.create(CheckObjectStep) catch @panic("OOM");	29	const self = gpa.create(CheckObject) catch @panic("OOM");
30	self.* = .{	30	self.* = .{
31	.step = Step.init(.{	31	.step = Step.init(.{
32	.id = .check_file,	32	.id = .check_file,
...	@@ -47,11 +47,11 @@ pub fn create(	...	@@ -47,11 +47,11 @@ pub fn create(
47	/// TODO this doesn't actually compare, and there's no apparent reason for it	47	/// TODO this doesn't actually compare, and there's no apparent reason for it
48	/// to depend on the check object step. I don't see why this function should exist,	48	/// to depend on the check object step. I don't see why this function should exist,
49	/// the caller could just add the run step directly.	49	/// the caller could just add the run step directly.
50	pub fn runAndCompare(self: CheckObjectStep) std.Build.RunStep {	50	pub fn runAndCompare(self: CheckObject) std.Build.Step.Run {
51	const dependencies_len = self.step.dependencies.items.len;	51	const dependencies_len = self.step.dependencies.items.len;
52	assert(dependencies_len > 0);	52	assert(dependencies_len > 0);
53	const exe_step = self.step.dependencies.items[dependencies_len - 1];	53	const exe_step = self.step.dependencies.items[dependencies_len - 1];
54	const exe = exe_step.cast(std.Build.CompileStep).?;	54	const exe = exe_step.cast(std.Build.Step.Compile).?;
55	const run = self.step.owner.addRunArtifact(exe);	55	const run = self.step.owner.addRunArtifact(exe);
56	run.skip_foreign_checks = true;	56	run.skip_foreign_checks = true;
57	run.step.dependOn(&self.step);	57	run.step.dependOn(&self.step);
...	@@ -274,15 +274,15 @@ const Check = struct {	...	@@ -274,15 +274,15 @@ const Check = struct {
274	};	274	};
275		275
276	/// Creates a new sequence of actions with `phrase` as the first anchor searched phrase.	276	/// Creates a new sequence of actions with `phrase` as the first anchor searched phrase.
277	pub fn checkStart(self: *CheckObjectStep, phrase: []const u8) void {	277	pub fn checkStart(self: *CheckObject, phrase: []const u8) void {
278	var new_check = Check.create(self.step.owner.allocator);	278	var new_check = Check.create(self.step.owner.allocator);
279	new_check.match(.{ .string = self.step.owner.dupe(phrase) });	279	new_check.match(.{ .string = self.step.owner.dupe(phrase) });
280	self.checks.append(new_check) catch @panic("OOM");	280	self.checks.append(new_check) catch @panic("OOM");
281	}	281	}
282		282
283	/// Adds another searched phrase to the latest created Check with `CheckObjectStep.checkStart(...)`.	283	/// Adds another searched phrase to the latest created Check with `CheckObject.checkStart(...)`.
284	/// Asserts at least one check already exists.	284	/// Asserts at least one check already exists.
285	pub fn checkNext(self: *CheckObjectStep, phrase: []const u8) void {	285	pub fn checkNext(self: *CheckObject, phrase: []const u8) void {
286	assert(self.checks.items.len > 0);	286	assert(self.checks.items.len > 0);
287	const last = &self.checks.items[self.checks.items.len - 1];	287	const last = &self.checks.items[self.checks.items.len - 1];
288	last.match(.{ .string = self.step.owner.dupe(phrase) });	288	last.match(.{ .string = self.step.owner.dupe(phrase) });
...	@@ -291,7 +291,7 @@ pub fn checkNext(self: *CheckObjectStep, phrase: []const u8) void {	...	@@ -291,7 +291,7 @@ pub fn checkNext(self: *CheckObjectStep, phrase: []const u8) void {
291	/// Like `checkNext()` but takes an additional argument `FileSource` which will be	291	/// Like `checkNext()` but takes an additional argument `FileSource` which will be
292	/// resolved to a full search query in `make()`.	292	/// resolved to a full search query in `make()`.
293	pub fn checkNextFileSource(	293	pub fn checkNextFileSource(
294	self: *CheckObjectStep,	294	self: *CheckObject,
295	phrase: []const u8,	295	phrase: []const u8,
296	file_source: std.Build.FileSource,	296	file_source: std.Build.FileSource,
297	) void {	297	) void {
...	@@ -300,10 +300,10 @@ pub fn checkNextFileSource(	...	@@ -300,10 +300,10 @@ pub fn checkNextFileSource(
300	last.match(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });	300	last.match(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });
301	}	301	}
302		302
303	/// Adds another searched phrase to the latest created Check with `CheckObjectStep.checkStart(...)`	303	/// Adds another searched phrase to the latest created Check with `CheckObject.checkStart(...)`
304	/// however ensures there is no matching phrase in the output.	304	/// however ensures there is no matching phrase in the output.
305	/// Asserts at least one check already exists.	305	/// Asserts at least one check already exists.
306	pub fn checkNotPresent(self: *CheckObjectStep, phrase: []const u8) void {	306	pub fn checkNotPresent(self: *CheckObject, phrase: []const u8) void {
307	assert(self.checks.items.len > 0);	307	assert(self.checks.items.len > 0);
308	const last = &self.checks.items[self.checks.items.len - 1];	308	const last = &self.checks.items[self.checks.items.len - 1];
309	last.notPresent(.{ .string = self.step.owner.dupe(phrase) });	309	last.notPresent(.{ .string = self.step.owner.dupe(phrase) });
...	@@ -312,7 +312,7 @@ pub fn checkNotPresent(self: *CheckObjectStep, phrase: []const u8) void {	...	@@ -312,7 +312,7 @@ pub fn checkNotPresent(self: *CheckObjectStep, phrase: []const u8) void {
312	/// Creates a new check checking specifically symbol table parsed and dumped from the object	312	/// Creates a new check checking specifically symbol table parsed and dumped from the object
313	/// file.	313	/// file.
314	/// Issuing this check will force parsing and dumping of the symbol table.	314	/// Issuing this check will force parsing and dumping of the symbol table.
315	pub fn checkInSymtab(self: *CheckObjectStep) void {	315	pub fn checkInSymtab(self: *CheckObject) void {
316	self.dump_symtab = true;	316	self.dump_symtab = true;
317	const symtab_label = switch (self.obj_format) {	317	const symtab_label = switch (self.obj_format) {
318	.macho => MachODumper.symtab_label,	318	.macho => MachODumper.symtab_label,
...	@@ -325,7 +325,7 @@ pub fn checkInSymtab(self: *CheckObjectStep) void {	...	@@ -325,7 +325,7 @@ pub fn checkInSymtab(self: *CheckObjectStep) void {
325	/// on the extracted variables. It will then compare the reduced program with the value of	325	/// on the extracted variables. It will then compare the reduced program with the value of
326	/// the expected variable.	326	/// the expected variable.
327	pub fn checkComputeCompare(	327	pub fn checkComputeCompare(
328	self: *CheckObjectStep,	328	self: *CheckObject,
329	program: []const u8,	329	program: []const u8,
330	expected: ComputeCompareExpected,	330	expected: ComputeCompareExpected,
331	) void {	331	) void {
...	@@ -338,7 +338,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -338,7 +338,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
338	_ = prog_node;	338	_ = prog_node;
339	const b = step.owner;	339	const b = step.owner;
340	const gpa = b.allocator;	340	const gpa = b.allocator;
341	const self = @fieldParentPtr(CheckObjectStep, "step", step);	341	const self = @fieldParentPtr(CheckObject, "step", step);
342		342
343	const src_path = self.source.getPath(b);	343	const src_path = self.source.getPath(b);
344	const contents = fs.cwd().readFileAllocOptions(	344	const contents = fs.cwd().readFileAllocOptions(

...	@@ -2,7 +2,7 @@ const std = @import("std");	...	@@ -2,7 +2,7 @@ const std = @import("std");
2	const Step = std.Build.Step;	2	const Step = std.Build.Step;
3	const FileSource = std.Build.FileSource;	3	const FileSource = std.Build.FileSource;
4	const InstallDir = std.Build.InstallDir;	4	const InstallDir = std.Build.InstallDir;
5	const InstallFileStep = @This();	5	const InstallFile = @This();
6	const assert = std.debug.assert;	6	const assert = std.debug.assert;
7		7
8	pub const base_id = .install_file;	8	pub const base_id = .install_file;
...	@@ -20,10 +20,10 @@ pub fn create(	...	@@ -20,10 +20,10 @@ pub fn create(
20	source: FileSource,	20	source: FileSource,
21	dir: InstallDir,	21	dir: InstallDir,
22	dest_rel_path: []const u8,	22	dest_rel_path: []const u8,
23	) *InstallFileStep {	23	) *InstallFile {
24	assert(dest_rel_path.len != 0);	24	assert(dest_rel_path.len != 0);
25	owner.pushInstalledFile(dir, dest_rel_path);	25	owner.pushInstalledFile(dir, dest_rel_path);
26	const self = owner.allocator.create(InstallFileStep) catch @panic("OOM");	26	const self = owner.allocator.create(InstallFile) catch @panic("OOM");
27	self.* = .{	27	self.* = .{
28	.step = Step.init(.{	28	.step = Step.init(.{
29	.id = base_id,	29	.id = base_id,
...	@@ -43,7 +43,7 @@ pub fn create(	...	@@ -43,7 +43,7 @@ pub fn create(
43	fn make(step: Step, prog_node: std.Progress.Node) !void {	43	fn make(step: Step, prog_node: std.Progress.Node) !void {
44	_ = prog_node;	44	_ = prog_node;
45	const src_builder = step.owner;	45	const src_builder = step.owner;
46	const self = @fieldParentPtr(InstallFileStep, "step", step);	46	const self = @fieldParentPtr(InstallFile, "step", step);
47	const dest_builder = self.dest_builder;	47	const dest_builder = self.dest_builder;
48	const full_src_path = self.source.getPath2(src_builder, step);	48	const full_src_path = self.source.getPath2(src_builder, step);
49	const full_dest_path = dest_builder.getInstallPath(self.dir, self.dest_rel_path);	49	const full_dest_path = dest_builder.getInstallPath(self.dir, self.dest_rel_path);

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	//! WriteFileStep is primarily used to create a directory in an appropriate	1	//! WriteFile is primarily used to create a directory in an appropriate
2	//! location inside the local cache which has a set of files that have either	2	//! location inside the local cache which has a set of files that have either
3	//! been generated during the build, or are copied from the source package.	3	//! been generated during the build, or are copied from the source package.
4	//!	4	//!
...	@@ -12,7 +12,7 @@ const std = @import("std");	...	@@ -12,7 +12,7 @@ const std = @import("std");
12	const Step = std.Build.Step;	12	const Step = std.Build.Step;
13	const fs = std.fs;	13	const fs = std.fs;
14	const ArrayList = std.ArrayList;	14	const ArrayList = std.ArrayList;
15	const WriteFileStep = @This();	15	const WriteFile = @This();
16		16
17	step: Step,	17	step: Step,
18	/// The elements here are pointers because we need stable pointers for the	18	/// The elements here are pointers because we need stable pointers for the
...	@@ -39,8 +39,8 @@ pub const Contents = union(enum) {	...	@@ -39,8 +39,8 @@ pub const Contents = union(enum) {
39	copy: std.Build.FileSource,	39	copy: std.Build.FileSource,
40	};	40	};
41		41
42	pub fn create(owner: std.Build) WriteFileStep {	42	pub fn create(owner: std.Build) WriteFile {
43	const wf = owner.allocator.create(WriteFileStep) catch @panic("OOM");	43	const wf = owner.allocator.create(WriteFile) catch @panic("OOM");
44	wf.* = .{	44	wf.* = .{
45	.step = Step.init(.{	45	.step = Step.init(.{
46	.id = .write_file,	46	.id = .write_file,
...	@@ -55,7 +55,7 @@ pub fn create(owner: std.Build) WriteFileStep {	...	@@ -55,7 +55,7 @@ pub fn create(owner: std.Build) WriteFileStep {
55	return wf;	55	return wf;
56	}	56	}
57		57
58	pub fn add(wf: *WriteFileStep, sub_path: []const u8, bytes: []const u8) void {	58	pub fn add(wf: *WriteFile, sub_path: []const u8, bytes: []const u8) void {
59	const b = wf.step.owner;	59	const b = wf.step.owner;
60	const gpa = b.allocator;	60	const gpa = b.allocator;
61	const file = gpa.create(File) catch @panic("OOM");	61	const file = gpa.create(File) catch @panic("OOM");
...	@@ -72,11 +72,11 @@ pub fn add(wf: *WriteFileStep, sub_path: []const u8, bytes: []const u8) void {	...	@@ -72,11 +72,11 @@ pub fn add(wf: *WriteFileStep, sub_path: []const u8, bytes: []const u8) void {
72	/// Place the file into the generated directory within the local cache,	72	/// Place the file into the generated directory within the local cache,
73	/// along with all the rest of the files added to this step. The parameter	73	/// along with all the rest of the files added to this step. The parameter
74	/// here is the destination path relative to the local cache directory	74	/// here is the destination path relative to the local cache directory
75	/// associated with this WriteFileStep. It may be a basename, or it may	75	/// associated with this WriteFile. It may be a basename, or it may
76	/// include sub-directories, in which case this step will ensure the	76	/// include sub-directories, in which case this step will ensure the
77	/// required sub-path exists.	77	/// required sub-path exists.
78	/// This is the option expected to be used most commonly with `addCopyFile`.	78	/// This is the option expected to be used most commonly with `addCopyFile`.
79	pub fn addCopyFile(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: []const u8) void {	79	pub fn addCopyFile(wf: *WriteFile, source: std.Build.FileSource, sub_path: []const u8) void {
80	const b = wf.step.owner;	80	const b = wf.step.owner;
81	const gpa = b.allocator;	81	const gpa = b.allocator;
82	const file = gpa.create(File) catch @panic("OOM");	82	const file = gpa.create(File) catch @panic("OOM");
...	@@ -97,7 +97,7 @@ pub fn addCopyFile(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: [	...	@@ -97,7 +97,7 @@ pub fn addCopyFile(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: [
97	/// run by a developer with intent to modify source files and then commit	97	/// run by a developer with intent to modify source files and then commit
98	/// those changes to version control.	98	/// those changes to version control.
99	/// A file added this way is not available with `getFileSource`.	99	/// A file added this way is not available with `getFileSource`.
100	pub fn addCopyFileToSource(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: []const u8) void {	100	pub fn addCopyFileToSource(wf: *WriteFile, source: std.Build.FileSource, sub_path: []const u8) void {
101	const b = wf.step.owner;	101	const b = wf.step.owner;
102	wf.output_source_files.append(b.allocator, .{	102	wf.output_source_files.append(b.allocator, .{
103	.contents = .{ .copy = source },	103	.contents = .{ .copy = source },
...	@@ -112,7 +112,7 @@ pub fn addCopyFileToSource(wf: *WriteFileStep, source: std.Build.FileSource, sub	...	@@ -112,7 +112,7 @@ pub fn addCopyFileToSource(wf: *WriteFileStep, source: std.Build.FileSource, sub
112	/// run by a developer with intent to modify source files and then commit	112	/// run by a developer with intent to modify source files and then commit
113	/// those changes to version control.	113	/// those changes to version control.
114	/// A file added this way is not available with `getFileSource`.	114	/// A file added this way is not available with `getFileSource`.
115	pub fn addBytesToSource(wf: *WriteFileStep, bytes: []const u8, sub_path: []const u8) void {	115	pub fn addBytesToSource(wf: *WriteFile, bytes: []const u8, sub_path: []const u8) void {
116	const b = wf.step.owner;	116	const b = wf.step.owner;
117	wf.output_source_files.append(b.allocator, .{	117	wf.output_source_files.append(b.allocator, .{
118	.contents = .{ .bytes = bytes },	118	.contents = .{ .bytes = bytes },
...	@@ -121,7 +121,7 @@ pub fn addBytesToSource(wf: *WriteFileStep, bytes: []const u8, sub_path: []const	...	@@ -121,7 +121,7 @@ pub fn addBytesToSource(wf: *WriteFileStep, bytes: []const u8, sub_path: []const
121	}	121	}
122		122
123	/// Gets a file source for the given sub_path. If the file does not exist, returns `null`.	123	/// Gets a file source for the given sub_path. If the file does not exist, returns `null`.
124	pub fn getFileSource(wf: *WriteFileStep, sub_path: []const u8) ?std.Build.FileSource {	124	pub fn getFileSource(wf: *WriteFile, sub_path: []const u8) ?std.Build.FileSource {
125	for (wf.files.items) \|file\| {	125	for (wf.files.items) \|file\| {
126	if (std.mem.eql(u8, file.sub_path, sub_path)) {	126	if (std.mem.eql(u8, file.sub_path, sub_path)) {
127	return .{ .generated = &file.generated_file };	127	return .{ .generated = &file.generated_file };
...	@@ -131,12 +131,12 @@ pub fn getFileSource(wf: *WriteFileStep, sub_path: []const u8) ?std.Build.FileSo	...	@@ -131,12 +131,12 @@ pub fn getFileSource(wf: *WriteFileStep, sub_path: []const u8) ?std.Build.FileSo
131	}	131	}
132		132
133	/// Returns a `FileSource` representing the base directory that contains all the	133	/// Returns a `FileSource` representing the base directory that contains all the
134	/// files from this `WriteFileStep`.	134	/// files from this `WriteFile`.
135	pub fn getDirectorySource(wf: *WriteFileStep) std.Build.FileSource {	135	pub fn getDirectorySource(wf: *WriteFile) std.Build.FileSource {
136	return .{ .generated = &wf.generated_directory };	136	return .{ .generated = &wf.generated_directory };
137	}	137	}
138		138
139	fn maybeUpdateName(wf: *WriteFileStep) void {	139	fn maybeUpdateName(wf: *WriteFile) void {
140	if (wf.files.items.len == 1) {	140	if (wf.files.items.len == 1) {
141	// First time adding a file; update name.	141	// First time adding a file; update name.
142	if (std.mem.eql(u8, wf.step.name, "WriteFile")) {	142	if (std.mem.eql(u8, wf.step.name, "WriteFile")) {
...	@@ -148,10 +148,10 @@ fn maybeUpdateName(wf: *WriteFileStep) void {	...	@@ -148,10 +148,10 @@ fn maybeUpdateName(wf: *WriteFileStep) void {
148	fn make(step: Step, prog_node: std.Progress.Node) !void {	148	fn make(step: Step, prog_node: std.Progress.Node) !void {
149	_ = prog_node;	149	_ = prog_node;
150	const b = step.owner;	150	const b = step.owner;
151	const wf = @fieldParentPtr(WriteFileStep, "step", step);	151	const wf = @fieldParentPtr(WriteFile, "step", step);
152		152
153	// Writing to source files is kind of an extra capability of this	153	// Writing to source files is kind of an extra capability of this
154	// WriteFileStep - arguably it should be a different step. But anyway here	154	// WriteFile - arguably it should be a different step. But anyway here
155	// it is, it happens unconditionally and does not interact with the other	155	// it is, it happens unconditionally and does not interact with the other
156	// files here.	156	// files here.
157	var any_miss = false;	157	var any_miss = false;
...	@@ -194,14 +194,14 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -194,14 +194,14 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
194	// the data to a file would probably be very fast - but as a way to find a canonical	194	// the data to a file would probably be very fast - but as a way to find a canonical
195	// location to put build artifacts.	195	// location to put build artifacts.
196		196
197	// If, for example, a hard-coded path was used as the location to put WriteFileStep	197	// If, for example, a hard-coded path was used as the location to put WriteFile
198	// files, then two WriteFileSteps executing in parallel might clobber each other.	198	// files, then two WriteFiles executing in parallel might clobber each other.
199		199
200	var man = b.cache.obtain();	200	var man = b.cache.obtain();
201	defer man.deinit();	201	defer man.deinit();
202		202
203	// Random bytes to make WriteFileStep unique. Refresh this with	203	// Random bytes to make WriteFile unique. Refresh this with
204	// new random bytes when WriteFileStep implementation is modified	204	// new random bytes when WriteFile implementation is modified
205	// in a non-backwards-compatible way.	205	// in a non-backwards-compatible way.
206	man.hash.add(@as(u32, 0xd767ee59));	206	man.hash.add(@as(u32, 0xd767ee59));
207		207

std.Build: use Step.* instead of *Step