combine std.build and std.build.Builder into std.Build

I've been wanting to do this for along time.

build.zig

@@ -1,19 +1,18 @@
 const std = @import("std");
 const builtin = std.builtin;
-const Builder = std.build.Builder;
 const tests = @import("test/tests.zig");
 const BufMap = std.BufMap;
 const mem = std.mem;
 const ArrayList = std.ArrayList;
 const io = std.io;
 const fs = std.fs;
-const InstallDirectoryOptions = std.build.InstallDirectoryOptions;
+const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
 const assert = std.debug.assert;
 
 const zig_version = std.builtin.Version{ .major = 0, .minor = 11, .patch = 0 };
 const stack_size = 32 * 1024 * 1024;
 
-pub fn build(b: *Builder) !void {
+pub fn build(b: *std.Build) !void {
     const release = b.option(bool, "release", "Build in release mode") orelse false;
     const only_c = b.option(bool, "only-c", "Translate the Zig compiler to C code, with only the C backend enabled") orelse false;
     const target = t: {
@@ -477,7 +476,7 @@ pub fn build(b: *Builder) !void {
     try addWasiUpdateStep(b, version);
 }
 
-fn addWasiUpdateStep(b: *Builder, version: [:0]const u8) !void {
+fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
     const semver = try std.SemanticVersion.parse(version);
 
     var target: std.zig.CrossTarget = .{
@@ -514,10 +513,10 @@ fn addWasiUpdateStep(b: *Builder, version: [:0]const u8) !void {
 }
 
 fn addCompilerStep(
-    b: *Builder,
+    b: *std.Build,
     optimize: std.builtin.OptimizeMode,
     target: std.zig.CrossTarget,
-) *std.build.LibExeObjStep {
+) *std.Build.LibExeObjStep {
     const exe = b.addExecutable(.{
         .name = "zig",
         .root_source_file = .{ .path = "src/main.zig" },
@@ -543,9 +542,9 @@ const exe_cflags = [_][]const u8{
 };
 
 fn addCmakeCfgOptionsToExe(
-    b: *Builder,
+    b: *std.Build,
     cfg: CMakeConfig,
-    exe: *std.build.LibExeObjStep,
+    exe: *std.Build.LibExeObjStep,
     use_zig_libcxx: bool,
 ) !void {
     if (exe.target.isDarwin()) {
@@ -624,7 +623,7 @@ fn addCmakeCfgOptionsToExe(
     }
 }
 
-fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
+fn addStaticLlvmOptionsToExe(exe: *std.Build.LibExeObjStep) !void {
     // Adds the Zig C++ sources which both stage1 and stage2 need.
     //
     // We need this because otherwise zig_clang_cc1_main.cpp ends up pulling
@@ -661,9 +660,9 @@ fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
 }
 
 fn addCxxKnownPath(
-    b: *Builder,
+    b: *std.Build,
     ctx: CMakeConfig,
-    exe: *std.build.LibExeObjStep,
+    exe: *std.Build.LibExeObjStep,
     objname: []const u8,
     errtxt: ?[]const u8,
     need_cpp_includes: bool,
@@ -696,7 +695,7 @@ fn addCxxKnownPath(
     }
 }
 
-fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
+fn addCMakeLibraryList(exe: *std.Build.LibExeObjStep, list: []const u8) void {
     var it = mem.tokenize(u8, list, ";");
     while (it.next()) |lib| {
         if (mem.startsWith(u8, lib, "-l")) {
@@ -710,7 +709,7 @@ fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
 }
 
 const CMakeConfig = struct {
-    llvm_linkage: std.build.LibExeObjStep.Linkage,
+    llvm_linkage: std.Build.LibExeObjStep.Linkage,
     cmake_binary_dir: []const u8,
     cmake_prefix_path: []const u8,
     cmake_static_library_prefix: []const u8,
@@ -727,7 +726,7 @@ const CMakeConfig = struct {
 
 const max_config_h_bytes = 1 * 1024 * 1024;
 
-fn findConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?[]const u8 {
+fn findConfigH(b: *std.Build, config_h_path_option: ?[]const u8) ?[]const u8 {
     if (config_h_path_option) |path| {
         var config_h_or_err = fs.cwd().openFile(path, .{});
         if (config_h_or_err) |*file| {
@@ -773,7 +772,7 @@ fn findConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?[]const u8 {
     } else unreachable; // TODO should not need `else unreachable`.
 }
 
-fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
+fn parseConfigH(b: *std.Build, config_h_text: []const u8) ?CMakeConfig {
     var ctx: CMakeConfig = .{
         .llvm_linkage = undefined,
         .cmake_binary_dir = undefined,
@@ -862,7 +861,7 @@ fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
     return ctx;
 }
 
-fn toNativePathSep(b: *Builder, s: []const u8) []u8 {
+fn toNativePathSep(b: *std.Build, s: []const u8) []u8 {
     const duplicated = b.allocator.dupe(u8, s) catch unreachable;
     for (duplicated) |*byte| switch (byte.*) {
         '/' => byte.* = fs.path.sep,

doc/langref.html.in

@@ -9528,9 +9528,9 @@ fn foo(comptime T: type, ptr: *T) T {
       To add standard build options to a <code class="file">build.zig</code> file:
       </p>
       {#code_begin|syntax|build#}
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const exe = b.addExecutable(.{
         .name = "example",
@@ -10551,9 +10551,9 @@ const separator = if (builtin.os.tag == .windows) '\\' else '/';
       <p>This <code class="file">build.zig</code> file is automatically generated
         by <kbd>zig init-exe</kbd>.</p>
       {#code_begin|syntax|build_executable#}
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options
@@ -10588,9 +10588,9 @@ pub fn build(b: *Builder) void {
       <p>This <code class="file">build.zig</code> file is automatically generated
         by <kbd>zig init-lib</kbd>.</p>
       {#code_begin|syntax|build_library#}
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const lib = b.addStaticLibrary(.{
         .name = "example",
@@ -10961,9 +10961,9 @@ int main(int argc, char **argv) {
 }
       {#end_syntax_block#}
       {#code_begin|syntax|build_c#}
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));
 
     const exe = b.addExecutable(.{
@@ -11025,9 +11025,9 @@ int main(int argc, char **argv) {
 }
       {#end_syntax_block#}
       {#code_begin|syntax|build_object#}
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const obj = b.addObject("base64", "base64.zig");
 
     const exe = b.addExecutable(.{

lib/build_runner.zig

@@ -3,7 +3,6 @@ const std = @import("std");
 const builtin = @import("builtin");
 const io = std.io;
 const fmt = std.fmt;
-const Builder = std.build.Builder;
 const mem = std.mem;
 const process = std.process;
 const ArrayList = std.ArrayList;
@@ -42,7 +41,7 @@ pub fn main() !void {
         return error.InvalidArgs;
     };
 
-    const builder = try Builder.create(
+    const builder = try std.Build.create(
         allocator,
         zig_exe,
         build_root,
@@ -58,7 +57,7 @@ pub fn main() !void {
     const stdout_stream = io.getStdOut().writer();
 
     var install_prefix: ?[]const u8 = null;
-    var dir_list = Builder.DirList{};
+    var dir_list = std.Build.DirList{};
 
     // before arg parsing, check for the NO_COLOR environment variable
     // if it exists, default the color setting to .off
@@ -230,7 +229,7 @@ pub fn main() !void {
     };
 }
 
-fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void {
+fn usage(builder: *std.Build, already_ran_build: bool, out_stream: anytype) !void {
     // run the build script to collect the options
     if (!already_ran_build) {
         builder.resolveInstallPrefix(null, .{});
@@ -330,7 +329,7 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void
     );
 }
 
-fn usageAndErr(builder: *Builder, already_ran_build: bool, out_stream: anytype) void {
+fn usageAndErr(builder: *std.Build, already_ran_build: bool, out_stream: anytype) void {
     usage(builder, already_ran_build, out_stream) catch {};
     process.exit(1);
 }

lib/init-exe/build.zig

@@ -3,7 +3,7 @@ const std = @import("std");
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
 // runner.
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options

lib/init-lib/build.zig

@@ -3,7 +3,7 @@ const std = @import("std");
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
 // runner.
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options

lib/std/Build/CheckFileStep.zig

@@ -1,7 +1,5 @@
 const std = @import("../std.zig");
-const build = std.build;
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
 const fs = std.fs;
 const mem = std.mem;
 
@@ -10,14 +8,14 @@ const CheckFileStep = @This();
 pub const base_id = .check_file;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 expected_matches: []const []const u8,
-source: build.FileSource,
+source: std.Build.FileSource,
 max_bytes: usize = 20 * 1024 * 1024,
 
 pub fn create(
-    builder: *Builder,
+    builder: *std.Build,
-    source: build.FileSource,
+    source: std.Build.FileSource,
     expected_matches: []const []const u8,
 ) *CheckFileStep {
     const self = builder.allocator.create(CheckFileStep) catch unreachable;

lib/std/Build/CheckObjectStep.zig

@@ -1,6 +1,5 @@
 const std = @import("../std.zig");
 const assert = std.debug.assert;
-const build = std.build;
 const fs = std.fs;
 const macho = std.macho;
 const math = std.math;
@@ -10,21 +9,20 @@ const testing = std.testing;
 const CheckObjectStep = @This();
 
 const Allocator = mem.Allocator;
-const Builder = build.Builder;
+const Step = std.Build.Step;
-const Step = build.Step;
+const EmulatableRunStep = std.Build.EmulatableRunStep;
-const EmulatableRunStep = build.EmulatableRunStep;
 
 pub const base_id = .check_object;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
-source: build.FileSource,
+source: std.Build.FileSource,
 max_bytes: usize = 20 * 1024 * 1024,
 checks: std.ArrayList(Check),
 dump_symtab: bool = false,
 obj_format: std.Target.ObjectFormat,
 
-pub fn create(builder: *Builder, source: build.FileSource, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
+pub fn create(builder: *std.Build, source: std.Build.FileSource, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
     const gpa = builder.allocator;
     const self = gpa.create(CheckObjectStep) catch unreachable;
     self.* = .{
@@ -44,7 +42,7 @@ pub fn runAndCompare(self: *CheckObjectStep) *EmulatableRunStep {
     const dependencies_len = self.step.dependencies.items.len;
     assert(dependencies_len > 0);
     const exe_step = self.step.dependencies.items[dependencies_len - 1];
-    const exe = exe_step.cast(std.build.LibExeObjStep).?;
+    const exe = exe_step.cast(std.Build.LibExeObjStep).?;
     const emulatable_step = EmulatableRunStep.create(self.builder, "EmulatableRun", exe);
     emulatable_step.step.dependOn(&self.step);
     return emulatable_step;
@@ -216,10 +214,10 @@ const ComputeCompareExpected = struct {
 };
 
 const Check = struct {
-    builder: *Builder,
+    builder: *std.Build,
     actions: std.ArrayList(Action),
 
-    fn create(b: *Builder) Check {
+    fn create(b: *std.Build) Check {
         return .{
             .builder = b,
             .actions = std.ArrayList(Action).init(b.allocator),

lib/std/Build/ConfigHeaderStep.zig

@@ -1,7 +1,6 @@
 const std = @import("../std.zig");
 const ConfigHeaderStep = @This();
-const Step = std.build.Step;
+const Step = std.Build.Step;
-const Builder = std.build.Builder;
 
 pub const base_id: Step.Id = .config_header;
 
@@ -24,15 +23,15 @@ pub const Value = union(enum) {
 };
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
-source: std.build.FileSource,
+source: std.Build.FileSource,
 style: Style,
 values: std.StringHashMap(Value),
 max_bytes: usize = 2 * 1024 * 1024,
 output_dir: []const u8,
 output_basename: []const u8,
 
-pub fn create(builder: *Builder, source: std.build.FileSource, style: Style) *ConfigHeaderStep {
+pub fn create(builder: *std.Build, source: std.Build.FileSource, style: Style) *ConfigHeaderStep {
     const self = builder.allocator.create(ConfigHeaderStep) catch @panic("OOM");
     const name = builder.fmt("configure header {s}", .{source.getDisplayName()});
     self.* = .{

lib/std/Build/EmulatableRunStep.zig

@@ -5,11 +5,9 @@
 //! without having to verify if it's possible to be ran against.
 
 const std = @import("../std.zig");
-const build = std.build;
+const Step = std.Build.Step;
-const Step = std.build.Step;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const Builder = std.build.Builder;
+const RunStep = std.Build.RunStep;
-const LibExeObjStep = std.build.LibExeObjStep;
-const RunStep = std.build.RunStep;
 
 const fs = std.fs;
 const process = std.process;
@@ -22,7 +20,7 @@ pub const base_id = .emulatable_run;
 const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 
 /// The artifact (executable) to be run by this step
 exe: *LibExeObjStep,
@@ -47,7 +45,7 @@ hide_foreign_binaries_warning: bool,
 /// binary through emulation when any of the emulation options such as `enable_rosetta` are set to true.
 /// When set to false, and the binary is foreign, running the executable is skipped.
 /// Asserts given artifact is an executable.
-pub fn create(builder: *Builder, name: []const u8, artifact: *LibExeObjStep) *EmulatableRunStep {
+pub fn create(builder: *std.Build, name: []const u8, artifact: *LibExeObjStep) *EmulatableRunStep {
     std.debug.assert(artifact.kind == .exe or artifact.kind == .test_exe);
     const self = builder.allocator.create(EmulatableRunStep) catch unreachable;
 

lib/std/Build/FmtStep.zig

@@ -1,19 +1,14 @@
 const std = @import("../std.zig");
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
-const BufMap = std.BufMap;
-const mem = std.mem;
-
 const FmtStep = @This();
 
 pub const base_id = .fmt;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 argv: [][]const u8,
 
-pub fn create(builder: *Builder, paths: []const []const u8) *FmtStep {
+pub fn create(builder: *std.Build, paths: []const []const u8) *FmtStep {
     const self = builder.allocator.create(FmtStep) catch unreachable;
     const name = "zig fmt";
     self.* = FmtStep{

lib/std/Build/InstallArtifactStep.zig

@@ -1,26 +1,23 @@
 const std = @import("../std.zig");
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const Builder = build.Builder;
+const InstallDir = std.Build.InstallDir;
-const LibExeObjStep = std.build.LibExeObjStep;
+const InstallArtifactStep = @This();
-const InstallDir = std.build.InstallDir;
 
 pub const base_id = .install_artifact;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 artifact: *LibExeObjStep,
 dest_dir: InstallDir,
 pdb_dir: ?InstallDir,
 h_dir: ?InstallDir,
 
-const Self = @This();
+pub fn create(builder: *std.Build, artifact: *LibExeObjStep) *InstallArtifactStep {
-
-pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
     if (artifact.install_step) |s| return s;
 
-    const self = builder.allocator.create(Self) catch unreachable;
+    const self = builder.allocator.create(InstallArtifactStep) catch unreachable;
-    self.* = Self{
+    self.* = InstallArtifactStep{
         .builder = builder,
         .step = Step.init(.install_artifact, builder.fmt("install {s}", .{artifact.step.name}), builder.allocator, make),
         .artifact = artifact,
@@ -64,7 +61,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
 }
 
 fn make(step: *Step) !void {
-    const self = @fieldParentPtr(Self, "step", step);
+    const self = @fieldParentPtr(InstallArtifactStep, "step", step);
     const builder = self.builder;
 
     const full_dest_path = builder.getInstallPath(self.dest_dir, self.artifact.out_filename);

lib/std/Build/InstallDirStep.zig

@@ -1,19 +1,17 @@
 const std = @import("../std.zig");
 const mem = std.mem;
 const fs = std.fs;
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
+const InstallDir = std.Build.InstallDir;
-const Builder = build.Builder;
-const InstallDir = std.build.InstallDir;
 const InstallDirStep = @This();
 const log = std.log;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 options: Options,
 /// This is used by the build system when a file being installed comes from one
 /// package but is being installed by another.
-override_source_builder: ?*Builder = null,
+override_source_builder: ?*std.Build = null,
 
 pub const base_id = .install_dir;
 
@@ -31,7 +29,7 @@ pub const Options = struct {
     /// `@import("test.zig")` would be a compile error.
     blank_extensions: []const []const u8 = &.{},
 
-    fn dupe(self: Options, b: *Builder) Options {
+    fn dupe(self: Options, b: *std.Build) Options {
         return .{
             .source_dir = b.dupe(self.source_dir),
             .install_dir = self.install_dir.dupe(b),
@@ -43,7 +41,7 @@ pub const Options = struct {
 };
 
 pub fn init(
-    builder: *Builder,
+    builder: *std.Build,
     options: Options,
 ) InstallDirStep {
     builder.pushInstalledFile(options.install_dir, options.install_subdir);

lib/std/Build/InstallFileStep.zig

@@ -1,24 +1,22 @@
 const std = @import("../std.zig");
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
+const FileSource = std.Build.FileSource;
-const Builder = build.Builder;
+const InstallDir = std.Build.InstallDir;
-const FileSource = std.build.FileSource;
-const InstallDir = std.build.InstallDir;
 const InstallFileStep = @This();
 
 pub const base_id = .install_file;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 source: FileSource,
 dir: InstallDir,
 dest_rel_path: []const u8,
 /// This is used by the build system when a file being installed comes from one
 /// package but is being installed by another.
-override_source_builder: ?*Builder = null,
+override_source_builder: ?*std.Build = null,
 
 pub fn init(
-    builder: *Builder,
+    builder: *std.Build,
     source: FileSource,
     dir: InstallDir,
     dest_rel_path: []const u8,

lib/std/Build/InstallRawStep.zig

@@ -7,11 +7,10 @@ const InstallRawStep = @This();
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
 const ArrayListUnmanaged = std.ArrayListUnmanaged;
-const Builder = std.build.Builder;
 const File = std.fs.File;
-const InstallDir = std.build.InstallDir;
+const InstallDir = std.Build.InstallDir;
-const LibExeObjStep = std.build.LibExeObjStep;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const Step = std.build.Step;
+const Step = std.Build.Step;
 const elf = std.elf;
 const fs = std.fs;
 const io = std.io;
@@ -25,12 +24,12 @@ pub const RawFormat = enum {
 };
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 artifact: *LibExeObjStep,
 dest_dir: InstallDir,
 dest_filename: []const u8,
 options: CreateOptions,
-output_file: std.build.GeneratedFile,
+output_file: std.Build.GeneratedFile,
 
 pub const CreateOptions = struct {
     format: ?RawFormat = null,
@@ -39,7 +38,12 @@ pub const CreateOptions = struct {
     pad_to: ?u64 = null,
 };
 
-pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []const u8, options: CreateOptions) *InstallRawStep {
+pub fn create(
+    builder: *std.Build,
+    artifact: *LibExeObjStep,
+    dest_filename: []const u8,
+    options: CreateOptions,
+) *InstallRawStep {
     const self = builder.allocator.create(InstallRawStep) catch unreachable;
     self.* = InstallRawStep{
         .step = Step.init(.install_raw, builder.fmt("install raw binary {s}", .{artifact.step.name}), builder.allocator, make),
@@ -53,7 +57,7 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons
         },
         .dest_filename = dest_filename,
         .options = options,
-        .output_file = std.build.GeneratedFile{ .step = &self.step },
+        .output_file = std.Build.GeneratedFile{ .step = &self.step },
     };
     self.step.dependOn(&artifact.step);
 
@@ -61,8 +65,8 @@ pub fn create(builder: *Builder, artifact: *LibExeObjStep, dest_filename: []cons
     return self;
 }
 
-pub fn getOutputSource(self: *const InstallRawStep) std.build.FileSource {
+pub fn getOutputSource(self: *const InstallRawStep) std.Build.FileSource {
-    return std.build.FileSource{ .generated = &self.output_file };
+    return std.Build.FileSource{ .generated = &self.output_file };
 }
 
 fn make(step: *Step) !void {

lib/std/Build/LibExeObjStep.zig

@@ -9,32 +9,30 @@ const ArrayList = std.ArrayList;
 const StringHashMap = std.StringHashMap;
 const Sha256 = std.crypto.hash.sha2.Sha256;
 const Allocator = mem.Allocator;
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 const NativeTargetInfo = std.zig.system.NativeTargetInfo;
-const FileSource = std.build.FileSource;
+const FileSource = std.Build.FileSource;
-const PkgConfigPkg = Builder.PkgConfigPkg;
+const PkgConfigPkg = std.Build.PkgConfigPkg;
-const PkgConfigError = Builder.PkgConfigError;
+const PkgConfigError = std.Build.PkgConfigError;
-const ExecError = Builder.ExecError;
+const ExecError = std.Build.ExecError;
-const Pkg = std.build.Pkg;
+const Pkg = std.Build.Pkg;
-const VcpkgRoot = std.build.VcpkgRoot;
+const VcpkgRoot = std.Build.VcpkgRoot;
-const InstallDir = std.build.InstallDir;
+const InstallDir = std.Build.InstallDir;
-const InstallArtifactStep = std.build.InstallArtifactStep;
+const InstallArtifactStep = std.Build.InstallArtifactStep;
-const GeneratedFile = std.build.GeneratedFile;
+const GeneratedFile = std.Build.GeneratedFile;
-const InstallRawStep = std.build.InstallRawStep;
+const InstallRawStep = std.Build.InstallRawStep;
-const EmulatableRunStep = std.build.EmulatableRunStep;
+const EmulatableRunStep = std.Build.EmulatableRunStep;
-const CheckObjectStep = std.build.CheckObjectStep;
+const CheckObjectStep = std.Build.CheckObjectStep;
-const RunStep = std.build.RunStep;
+const RunStep = std.Build.RunStep;
-const OptionsStep = std.build.OptionsStep;
+const OptionsStep = std.Build.OptionsStep;
-const ConfigHeaderStep = std.build.ConfigHeaderStep;
+const ConfigHeaderStep = std.Build.ConfigHeaderStep;
 const LibExeObjStep = @This();
 
 pub const base_id = .lib_exe_obj;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 name: []const u8,
 target: CrossTarget,
 target_info: NativeTargetInfo,
@@ -84,7 +82,7 @@ initial_memory: ?u64 = null,
 max_memory: ?u64 = null,
 shared_memory: bool = false,
 global_base: ?u64 = null,
-c_std: Builder.CStd,
+c_std: std.Build.CStd,
 override_lib_dir: ?[]const u8,
 main_pkg_path: ?[]const u8,
 exec_cmd_args: ?[]const ?[]const u8,
@@ -108,7 +106,7 @@ object_src: []const u8,
 link_objects: ArrayList(LinkObject),
 include_dirs: ArrayList(IncludeDir),
 c_macros: ArrayList([]const u8),
-installed_headers: ArrayList(*std.build.Step),
+installed_headers: ArrayList(*Step),
 output_dir: ?[]const u8,
 is_linking_libc: bool = false,
 is_linking_libcpp: bool = false,
@@ -226,7 +224,7 @@ pub const CSourceFile = struct {
     source: FileSource,
     args: []const []const u8,
 
-    pub fn dupe(self: CSourceFile, b: *Builder) CSourceFile {
+    pub fn dupe(self: CSourceFile, b: *std.Build) CSourceFile {
         return .{
             .source = self.source.dupe(b),
             .args = b.dupeStrings(self.args),
@@ -297,7 +295,7 @@ pub const EmitOption = union(enum) {
     emit: void,
     emit_to: []const u8,
 
-    fn getArg(self: @This(), b: *Builder, arg_name: []const u8) ?[]const u8 {
+    fn getArg(self: @This(), b: *std.Build, arg_name: []const u8) ?[]const u8 {
         return switch (self) {
             .no_emit => b.fmt("-fno-{s}", .{arg_name}),
             .default => null,
@@ -307,7 +305,7 @@ pub const EmitOption = union(enum) {
     }
 };
 
-pub fn create(builder: *Builder, options: Options) *LibExeObjStep {
+pub fn create(builder: *std.Build, options: Options) *LibExeObjStep {
     const name = builder.dupe(options.name);
     const root_src: ?FileSource = if (options.root_source_file) |rsrc| rsrc.dupe(builder) else null;
     if (mem.indexOf(u8, name, "/") != null or mem.indexOf(u8, name, "\\") != null) {
@@ -343,9 +341,9 @@ pub fn create(builder: *Builder, options: Options) *LibExeObjStep {
         .lib_paths = ArrayList([]const u8).init(builder.allocator),
         .rpaths = ArrayList([]const u8).init(builder.allocator),
         .framework_dirs = ArrayList([]const u8).init(builder.allocator),
-        .installed_headers = ArrayList(*std.build.Step).init(builder.allocator),
+        .installed_headers = ArrayList(*Step).init(builder.allocator),
         .object_src = undefined,
-        .c_std = Builder.CStd.C99,
+        .c_std = std.Build.CStd.C99,
         .override_lib_dir = null,
         .main_pkg_path = null,
         .exec_cmd_args = null,
@@ -461,7 +459,7 @@ pub fn installHeadersDirectory(
 
 pub fn installHeadersDirectoryOptions(
     a: *LibExeObjStep,
-    options: std.build.InstallDirStep.Options,
+    options: std.Build.InstallDirStep.Options,
 ) void {
     const install_dir = a.builder.addInstallDirectory(options);
     a.builder.getInstallStep().dependOn(&install_dir.step);
@@ -600,7 +598,7 @@ pub fn linkLibCpp(self: *LibExeObjStep) void {
 /// 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: *LibExeObjStep, name: []const u8, value: ?[]const u8) void {
-    const macro = std.build.constructCMacro(self.builder.allocator, name, value);
+    const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
     self.c_macros.append(macro) catch unreachable;
 }
 
@@ -1460,7 +1458,7 @@ fn make(step: *Step) !void {
     if (!self.target.isNative()) {
         try zig_args.appendSlice(&.{
             "-target", try self.target.zigTriple(builder.allocator),
-            "-mcpu",   try build.serializeCpu(builder.allocator, self.target.getCpu()),
+            "-mcpu",   try std.Build.serializeCpu(builder.allocator, self.target.getCpu()),
         });
 
         if (self.target.dynamic_linker.get()) |dynamic_linker| {
@@ -1902,7 +1900,7 @@ pub fn doAtomicSymLinks(allocator: Allocator, output_path: []const u8, filename_
     };
 }
 
-fn execPkgConfigList(self: *Builder, out_code: *u8) (PkgConfigError || ExecError)![]const PkgConfigPkg {
+fn execPkgConfigList(self: *std.Build, out_code: *u8) (PkgConfigError || ExecError)![]const PkgConfigPkg {
     const stdout = try self.execAllowFail(&[_][]const u8{ "pkg-config", "--list-all" }, out_code, .Ignore);
     var list = ArrayList(PkgConfigPkg).init(self.allocator);
     errdefer list.deinit();
@@ -1918,7 +1916,7 @@ fn execPkgConfigList(self: *Builder, out_code: *u8) (PkgConfigError || ExecError
     return list.toOwnedSlice();
 }
 
-fn getPkgConfigList(self: *Builder) ![]const PkgConfigPkg {
+fn getPkgConfigList(self: *std.Build) ![]const PkgConfigPkg {
     if (self.pkg_config_pkg_list) |res| {
         return res;
     }
@@ -1948,7 +1946,7 @@ test "addPackage" {
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
 
-    var builder = try Builder.create(
+    var builder = try std.Build.create(
         arena.allocator(),
         "test",
         "test",

lib/std/Build/LogStep.zig

@@ -1,17 +1,15 @@
 const std = @import("../std.zig");
 const log = std.log;
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
 const LogStep = @This();
 
 pub const base_id = .log;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 data: []const u8,
 
-pub fn init(builder: *Builder, data: []const u8) LogStep {
+pub fn init(builder: *std.Build, data: []const u8) LogStep {
     return LogStep{
         .builder = builder,
         .step = Step.init(.log, builder.fmt("log {s}", .{data}), builder.allocator, make),

lib/std/Build/OptionsStep.zig

@@ -1,12 +1,10 @@
 const std = @import("../std.zig");
 const builtin = @import("builtin");
-const build = std.build;
 const fs = std.fs;
-const Step = build.Step;
+const Step = std.Build.Step;
-const Builder = build.Builder;
+const GeneratedFile = std.Build.GeneratedFile;
-const GeneratedFile = build.GeneratedFile;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const LibExeObjStep = build.LibExeObjStep;
+const FileSource = std.Build.FileSource;
-const FileSource = build.FileSource;
 
 const OptionsStep = @This();
 
@@ -14,13 +12,13 @@ pub const base_id = .options;
 
 step: Step,
 generated_file: GeneratedFile,
-builder: *Builder,
+builder: *std.Build,
 
 contents: std.ArrayList(u8),
 artifact_args: std.ArrayList(OptionArtifactArg),
 file_source_args: std.ArrayList(OptionFileSourceArg),
 
-pub fn create(builder: *Builder) *OptionsStep {
+pub fn create(builder: *std.Build) *OptionsStep {
     const self = builder.allocator.create(OptionsStep) catch unreachable;
     self.* = .{
         .builder = builder,
@@ -202,7 +200,7 @@ pub fn addOptionArtifact(self: *OptionsStep, name: []const u8, artifact: *LibExe
     self.step.dependOn(&artifact.step);
 }
 
-pub fn getPackage(self: *OptionsStep, package_name: []const u8) build.Pkg {
+pub fn getPackage(self: *OptionsStep, package_name: []const u8) std.Build.Pkg {
     return .{ .name = package_name, .source = self.getSource() };
 }
 
@@ -281,7 +279,7 @@ test "OptionsStep" {
 
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
-    var builder = try Builder.create(
+    var builder = try std.Build.create(
         arena.allocator(),
         "test",
         "test",

lib/std/Build/RemoveDirStep.zig

@@ -1,18 +1,16 @@
 const std = @import("../std.zig");
 const log = std.log;
 const fs = std.fs;
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
 const RemoveDirStep = @This();
 
 pub const base_id = .remove_dir;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 dir_path: []const u8,
 
-pub fn init(builder: *Builder, dir_path: []const u8) RemoveDirStep {
+pub fn init(builder: *std.Build, dir_path: []const u8) RemoveDirStep {
     return RemoveDirStep{
         .builder = builder,
         .step = Step.init(.remove_dir, builder.fmt("RemoveDir {s}", .{dir_path}), builder.allocator, make),

lib/std/Build/RunStep.zig

@@ -1,17 +1,15 @@
 const std = @import("../std.zig");
 const builtin = @import("builtin");
-const build = std.build;
+const Step = std.Build.Step;
-const Step = build.Step;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const Builder = build.Builder;
+const WriteFileStep = std.Build.WriteFileStep;
-const LibExeObjStep = build.LibExeObjStep;
-const WriteFileStep = build.WriteFileStep;
 const fs = std.fs;
 const mem = std.mem;
 const process = std.process;
 const ArrayList = std.ArrayList;
 const EnvMap = process.EnvMap;
 const Allocator = mem.Allocator;
-const ExecError = build.Builder.ExecError;
+const ExecError = std.Build.ExecError;
 
 const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
 
@@ -20,7 +18,7 @@ const RunStep = @This();
 pub const base_id: Step.Id = .run;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 
 /// See also addArg and addArgs to modifying this directly
 argv: ArrayList(Arg),
@@ -51,11 +49,11 @@ pub const StdIoAction = union(enum) {
 
 pub const Arg = union(enum) {
     artifact: *LibExeObjStep,
-    file_source: build.FileSource,
+    file_source: std.Build.FileSource,
     bytes: []u8,
 };
 
-pub fn create(builder: *Builder, name: []const u8) *RunStep {
+pub fn create(builder: *std.Build, name: []const u8) *RunStep {
     const self = builder.allocator.create(RunStep) catch unreachable;
     self.* = RunStep{
         .builder = builder,
@@ -73,7 +71,7 @@ pub fn addArtifactArg(self: *RunStep, artifact: *LibExeObjStep) void {
     self.step.dependOn(&artifact.step);
 }
 
-pub fn addFileSourceArg(self: *RunStep, file_source: build.FileSource) void {
+pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {
     self.argv.append(Arg{
         .file_source = file_source.dupe(self.builder),
     }) catch unreachable;
@@ -101,7 +99,7 @@ pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
 }
 
 /// For internal use only, users of `RunStep` should use `addPathDir` directly.
-pub fn addPathDirInternal(step: *Step, builder: *Builder, search_path: []const u8) void {
+pub fn addPathDirInternal(step: *Step, builder: *std.Build, search_path: []const u8) void {
     const env_map = getEnvMapInternal(step, builder.allocator);
 
     const key = "PATH";
@@ -122,7 +120,7 @@ pub fn getEnvMap(self: *RunStep) *EnvMap {
 fn getEnvMapInternal(step: *Step, allocator: Allocator) *EnvMap {
     const maybe_env_map = switch (step.id) {
         .run => step.cast(RunStep).?.env_map,
-        .emulatable_run => step.cast(build.EmulatableRunStep).?.env_map,
+        .emulatable_run => step.cast(std.Build.EmulatableRunStep).?.env_map,
         else => unreachable,
     };
     return maybe_env_map orelse {
@@ -195,7 +193,7 @@ fn make(step: *Step) !void {
 
 pub fn runCommand(
     argv: []const []const u8,
-    builder: *Builder,
+    builder: *std.Build,
     expected_exit_code: ?u8,
     stdout_action: StdIoAction,
     stderr_action: StdIoAction,
@@ -363,7 +361,7 @@ fn addPathForDynLibs(self: *RunStep, artifact: *LibExeObjStep) void {
 
 /// This should only be used for internal usage, this is called automatically
 /// for the user.
-pub fn addPathForDynLibsInternal(step: *Step, builder: *Builder, artifact: *LibExeObjStep) void {
+pub fn addPathForDynLibsInternal(step: *Step, builder: *std.Build, artifact: *LibExeObjStep) void {
     for (artifact.link_objects.items) |link_object| {
         switch (link_object) {
             .other_step => |other| {

lib/std/Build/Step.zig

@@ -0,0 +1,97 @@
+id: Id,
+name: []const u8,
+makeFn: *const fn (self: *Step) anyerror!void,
+dependencies: std.ArrayList(*Step),
+loop_flag: bool,
+done_flag: bool,
+
+pub const Id = enum {
+    top_level,
+    lib_exe_obj,
+    install_artifact,
+    install_file,
+    install_dir,
+    log,
+    remove_dir,
+    fmt,
+    translate_c,
+    write_file,
+    run,
+    emulatable_run,
+    check_file,
+    check_object,
+    config_header,
+    install_raw,
+    options,
+    custom,
+
+    pub fn Type(comptime id: Id) type {
+        return switch (id) {
+            .top_level => Build.TopLevelStep,
+            .lib_exe_obj => Build.LibExeObjStep,
+            .install_artifact => Build.InstallArtifactStep,
+            .install_file => Build.InstallFileStep,
+            .install_dir => Build.InstallDirStep,
+            .log => Build.LogStep,
+            .remove_dir => Build.RemoveDirStep,
+            .fmt => Build.FmtStep,
+            .translate_c => Build.TranslateCStep,
+            .write_file => Build.WriteFileStep,
+            .run => Build.RunStep,
+            .emulatable_run => Build.EmulatableRunStep,
+            .check_file => Build.CheckFileStep,
+            .check_object => Build.CheckObjectStep,
+            .config_header => Build.ConfigHeaderStep,
+            .install_raw => Build.InstallRawStep,
+            .options => Build.OptionsStep,
+            .custom => @compileError("no type available for custom step"),
+        };
+    }
+};
+
+pub fn init(
+    id: Id,
+    name: []const u8,
+    allocator: Allocator,
+    makeFn: *const fn (self: *Step) anyerror!void,
+) Step {
+    return Step{
+        .id = id,
+        .name = allocator.dupe(u8, name) catch unreachable,
+        .makeFn = makeFn,
+        .dependencies = std.ArrayList(*Step).init(allocator),
+        .loop_flag = false,
+        .done_flag = false,
+    };
+}
+
+pub fn initNoOp(id: Id, name: []const u8, allocator: Allocator) Step {
+    return init(id, name, allocator, makeNoOp);
+}
+
+pub fn make(self: *Step) !void {
+    if (self.done_flag) return;
+
+    try self.makeFn(self);
+    self.done_flag = true;
+}
+
+pub fn dependOn(self: *Step, other: *Step) void {
+    self.dependencies.append(other) catch unreachable;
+}
+
+fn makeNoOp(self: *Step) anyerror!void {
+    _ = self;
+}
+
+pub fn cast(step: *Step, comptime T: type) ?*T {
+    if (step.id == T.base_id) {
+        return @fieldParentPtr(T, "step", step);
+    }
+    return null;
+}
+
+const Step = @This();
+const std = @import("../std.zig");
+const Build = std.Build;
+const Allocator = std.mem.Allocator;

lib/std/Build/TranslateCStep.zig

@@ -1,9 +1,7 @@
 const std = @import("../std.zig");
-const build = std.build;
+const Step = std.Build.Step;
-const Step = build.Step;
+const LibExeObjStep = std.Build.LibExeObjStep;
-const Builder = build.Builder;
+const CheckFileStep = std.Build.CheckFileStep;
-const LibExeObjStep = build.LibExeObjStep;
-const CheckFileStep = build.CheckFileStep;
 const fs = std.fs;
 const mem = std.mem;
 const CrossTarget = std.zig.CrossTarget;
@@ -13,23 +11,23 @@ const TranslateCStep = @This();
 pub const base_id = .translate_c;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
-source: build.FileSource,
+source: std.Build.FileSource,
 include_dirs: std.ArrayList([]const u8),
 c_macros: std.ArrayList([]const u8),
 output_dir: ?[]const u8,
 out_basename: []const u8,
 target: CrossTarget,
 optimize: std.builtin.OptimizeMode,
-output_file: build.GeneratedFile,
+output_file: std.Build.GeneratedFile,
 
 pub const Options = struct {
-    source_file: build.FileSource,
+    source_file: std.Build.FileSource,
     target: CrossTarget,
     optimize: std.builtin.OptimizeMode,
 };
 
-pub fn create(builder: *Builder, options: Options) *TranslateCStep {
+pub fn create(builder: *std.Build, options: Options) *TranslateCStep {
     const self = builder.allocator.create(TranslateCStep) catch unreachable;
     const source = options.source_file.dupe(builder);
     self.* = TranslateCStep{
@@ -42,7 +40,7 @@ pub fn create(builder: *Builder, options: Options) *TranslateCStep {
         .out_basename = undefined,
         .target = options.target,
         .optimize = options.optimize,
-        .output_file = build.GeneratedFile{ .step = &self.step },
+        .output_file = std.Build.GeneratedFile{ .step = &self.step },
     };
     source.addStepDependencies(&self.step);
     return self;
@@ -79,7 +77,7 @@ 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 {
-    const macro = build.constructCMacro(self.builder.allocator, name, value);
+    const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
     self.c_macros.append(macro) catch unreachable;
 }
 

lib/std/Build/WriteFileStep.zig

@@ -1,7 +1,5 @@
 const std = @import("../std.zig");
-const build = @import("../build.zig");
+const Step = std.Build.Step;
-const Step = build.Step;
-const Builder = build.Builder;
 const fs = std.fs;
 const ArrayList = std.ArrayList;
 
@@ -10,17 +8,17 @@ const WriteFileStep = @This();
 pub const base_id = .write_file;
 
 step: Step,
-builder: *Builder,
+builder: *std.Build,
 output_dir: []const u8,
 files: std.TailQueue(File),
 
 pub const File = struct {
-    source: build.GeneratedFile,
+    source: std.Build.GeneratedFile,
     basename: []const u8,
     bytes: []const u8,
 };
 
-pub fn init(builder: *Builder) WriteFileStep {
+pub fn init(builder: *std.Build) WriteFileStep {
     return WriteFileStep{
         .builder = builder,
         .step = Step.init(.write_file, "writefile", builder.allocator, make),
@@ -33,7 +31,7 @@ pub fn add(self: *WriteFileStep, basename: []const u8, bytes: []const u8) void {
     const node = self.builder.allocator.create(std.TailQueue(File).Node) catch unreachable;
     node.* = .{
         .data = .{
-            .source = build.GeneratedFile{ .step = &self.step },
+            .source = std.Build.GeneratedFile{ .step = &self.step },
             .basename = self.builder.dupePath(basename),
             .bytes = self.builder.dupe(bytes),
         },
@@ -43,11 +41,11 @@ pub fn add(self: *WriteFileStep, basename: []const u8, bytes: []const u8) void {
 }
 
 /// Gets a file source for the given basename. If the file does not exist, returns `null`.
-pub fn getFileSource(step: *WriteFileStep, basename: []const u8) ?build.FileSource {
+pub fn getFileSource(step: *WriteFileStep, basename: []const u8) ?std.Build.FileSource {
     var it = step.files.first;
     while (it) |node| : (it = node.next) {
         if (std.mem.eql(u8, node.data.basename, basename))
-            return build.FileSource{ .generated = &node.data.source };
+            return std.Build.FileSource{ .generated = &node.data.source };
     }
     return null;
 }

lib/std/std.zig

@@ -9,6 +9,7 @@ pub const AutoArrayHashMapUnmanaged = array_hash_map.AutoArrayHashMapUnmanaged;
 pub const AutoHashMap = hash_map.AutoHashMap;
 pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
 pub const BoundedArray = @import("bounded_array.zig").BoundedArray;
+pub const Build = @import("Build.zig");
 pub const BufMap = @import("buf_map.zig").BufMap;
 pub const BufSet = @import("buf_set.zig").BufSet;
 pub const ChildProcess = @import("child_process.zig").ChildProcess;
@@ -49,7 +50,6 @@ pub const array_hash_map = @import("array_hash_map.zig");
 pub const atomic = @import("atomic.zig");
 pub const base64 = @import("base64.zig");
 pub const bit_set = @import("bit_set.zig");
-pub const build = @import("build.zig");
 pub const builtin = @import("builtin.zig");
 pub const c = @import("c.zig");
 pub const coff = @import("coff.zig");
@@ -96,6 +96,12 @@ pub const wasm = @import("wasm.zig");
 pub const zig = @import("zig.zig");
 pub const start = @import("start.zig");
 
+///// Deprecated. Use `std.Build` instead.
+//pub const build = struct {
+//    /// Deprecated. Use `std.Build` instead.
+//    pub const Builder = Build;
+//};
+
 const root = @import("root");
 const options_override = if (@hasDecl(root, "std_options")) root.std_options else struct {};
 

test/link/bss/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const test_step = b.step("test", "Test");
 

test/link/common_symbols/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const lib_a = b.addStaticLibrary(.{

test/link/common_symbols_alignment/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/link/interdependent_static_c_libs/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/link/macho/bugs/13056/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };

test/link/macho/bugs/13457/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/dead_strip/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
@@ -37,7 +36,7 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const exe = b.addExecutable(.{
         .name = "test",
         .optimize = optimize,

test/link/macho/dead_strip_dylibs/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
@@ -36,7 +35,7 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
+fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
     const exe = b.addExecutable(.{
         .name = "test",
         .optimize = optimize,

test/link/macho/dylib/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/empty/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
@@ -17,7 +16,7 @@ pub fn build(b: *Builder) void {
     exe.addCSourceFile("empty.c", &[0][]const u8{});
     exe.linkLibC();
 
-    const run_cmd = std.build.EmulatableRunStep.create(b, "run", exe);
+    const run_cmd = std.Build.EmulatableRunStep.create(b, "run", exe);
     run_cmd.expectStdOutEqual("Hello!\n");
     test_step.dependOn(&run_cmd.step);
 }

test/link/macho/entry/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");

test/link/macho/headerpad/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");
@@ -94,7 +93,7 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn simpleExe(b: *Builder, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
+fn simpleExe(b: *std.Build, optimize: std.builtin.OptimizeMode) *LibExeObjectStep {
     const exe = b.addExecutable(.{
         .name = "main",
         .optimize = optimize,

test/link/macho/linksection/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = std.zig.CrossTarget{ .os_tag = .macos };
 

test/link/macho/needed_framework/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");

test/link/macho/needed_library/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/objc/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");
@@ -18,6 +17,6 @@ pub fn build(b: *Builder) void {
     // populate paths to the sysroot here.
     exe.linkFramework("Foundation");
 
-    const run_cmd = std.build.EmulatableRunStep.create(b, "run", exe);
+    const run_cmd = std.Build.EmulatableRunStep.create(b, "run", exe);
     test_step.dependOn(&run_cmd.step);
 }

test/link/macho/objcpp/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");

test/link/macho/pagezero/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/search_strategy/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
@@ -29,14 +28,14 @@ pub fn build(b: *Builder) void {
         const exe = createScenario(b, optimize, target);
         exe.search_strategy = .paths_first;
 
-        const run = std.build.EmulatableRunStep.create(b, "run", exe);
+        const run = std.Build.EmulatableRunStep.create(b, "run", exe);
         run.cwd = b.pathFromRoot(".");
         run.expectStdOutEqual("Hello world");
         test_step.dependOn(&run.step);
     }
 }
 
-fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const static = b.addStaticLibrary(.{
         .name = "a",
         .optimize = optimize,
@@ -44,7 +43,7 @@ fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.z
     });
     static.addCSourceFile("a.c", &.{});
     static.linkLibC();
-    static.override_dest_dir = std.build.InstallDir{
+    static.override_dest_dir = std.Build.InstallDir{
         .custom = "static",
     };
     static.install();
@@ -57,7 +56,7 @@ fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.z
     });
     dylib.addCSourceFile("a.c", &.{});
     dylib.linkLibC();
-    dylib.override_dest_dir = std.build.InstallDir{
+    dylib.override_dest_dir = std.Build.InstallDir{
         .custom = "dynamic",
     };
     dylib.install();

test/link/macho/stack_size/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/strict_validation/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/tls/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/macho/unwind_info/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
@@ -14,8 +13,8 @@ pub fn build(b: *Builder) void {
 }
 
 fn testUnwindInfo(
-    b: *Builder,
+    b: *std.Build,
-    test_step: *std.build.Step,
+    test_step: *std.Build.Step,
     optimize: std.builtin.OptimizeMode,
     target: std.zig.CrossTarget,
     dead_strip: bool,
@@ -52,7 +51,7 @@ fn testUnwindInfo(
     test_step.dependOn(&run_cmd.step);
 }
 
-fn createScenario(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+fn createScenario(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const exe = b.addExecutable(.{
         .name = "test",
         .optimize = optimize,

test/link/macho/uuid/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
@@ -27,8 +26,8 @@ pub fn build(b: *Builder) void {
 }
 
 fn testUuid(
-    b: *Builder,
+    b: *std.Build,
-    test_step: *std.build.Step,
+    test_step: *std.Build.Step,
     optimize: std.builtin.OptimizeMode,
     target: std.zig.CrossTarget,
     comptime exp: []const u8,
@@ -52,7 +51,7 @@ fn testUuid(
     }
 }
 
-fn simpleDylib(b: *Builder, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
+fn simpleDylib(b: *std.Build, optimize: std.builtin.OptimizeMode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const dylib = b.addSharedLibrary(.{
         .name = "test",
         .version = .{ .major = 1, .minor = 0 },

test/link/macho/weak_framework/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test the program");

test/link/macho/weak_library/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
-const Builder = std.build.Builder;
+const LibExeObjectStep = std.Build.LibExeObjStep;
-const LibExeObjectStep = std.build.LibExeObjStep;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 

test/link/static_lib_as_system_lib/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/link/wasm/archive/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/basic-features/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     // Library with explicitly set cpu features
     const lib = b.addSharedLibrary(.{
         .name = "lib",

test/link/wasm/bss/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/export-data/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/export/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const no_export = b.addSharedLibrary(.{

test/link/wasm/extern-mangle/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/extern/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const exe = b.addExecutable(.{
         .name = "extern",
         .root_source_file = .{ .path = "main.zig" },

test/link/wasm/function-table/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const test_step = b.step("test", "Test");

test/link/wasm/infer-features/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     // Wasm Object file which we will use to infer the features from

test/link/wasm/producers/build.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/segments/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/stack_pointer/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/link/wasm/type/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 

test/src/compare_output.zig

@@ -1,7 +1,6 @@
 // This is the implementation of the test harness.
 // For the actual test cases, see test/compare_output.zig.
 const std = @import("std");
-const build = std.build;
 const ArrayList = std.ArrayList;
 const fmt = std.fmt;
 const mem = std.mem;
@@ -9,8 +8,8 @@ const fs = std.fs;
 const OptimizeMode = std.builtin.OptimizeMode;
 
 pub const CompareOutputContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *std.Build.Step,
     test_index: usize,
     test_filter: ?[]const u8,
     optimize_modes: []const OptimizeMode,

test/src/run_translated_c.zig

@@ -1,15 +1,14 @@
 // This is the implementation of the test harness for running translated
 // C code. For the actual test cases, see test/run_translated_c.zig.
 const std = @import("std");
-const build = std.build;
 const ArrayList = std.ArrayList;
 const fmt = std.fmt;
 const mem = std.mem;
 const fs = std.fs;
 
 pub const RunTranslatedCContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *std.Build.Step,
     test_index: usize,
     test_filter: ?[]const u8,
     target: std.zig.CrossTarget,

test/src/translate_c.zig

@@ -1,7 +1,6 @@
 // This is the implementation of the test harness.
 // For the actual test cases, see test/translate_c.zig.
 const std = @import("std");
-const build = std.build;
 const ArrayList = std.ArrayList;
 const fmt = std.fmt;
 const mem = std.mem;
@@ -9,8 +8,8 @@ const fs = std.fs;
 const CrossTarget = std.zig.CrossTarget;
 
 pub const TranslateCContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *std.Build.Step,
     test_index: usize,
     test_filter: ?[]const u8,
 

test/standalone/brace_expansion/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const main = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },
         .optimize = b.standardOptimizeOption(.{}),

test/standalone/c_compiler/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
-// TODO integrate this with the std.build executor API
+// TODO integrate this with the std.Build executor API
 fn isRunnableTarget(t: CrossTarget) bool {
     if (t.isNative()) return true;
 
@@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
         t.getCpuArch() == builtin.cpu.arch);
 }
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/emit_asm_and_bin/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const main = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },
         .optimize = b.standardOptimizeOption(.{}),

test/standalone/empty_env/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const main = b.addExecutable(.{
         .name = "main",
         .root_source_file = .{ .path = "main.zig" },

test/standalone/global_linkage/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const obj1 = b.addStaticLibrary(.{

test/standalone/install_raw_hex/build.zig

@@ -1,8 +1,8 @@
 const builtin = @import("builtin");
 const std = @import("std");
-const CheckFileStep = std.build.CheckFileStep;
+const CheckFileStep = std.Build.CheckFileStep;
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const target = .{
         .cpu_arch = .thumb,
         .cpu_model = .{ .explicit = &std.Target.arm.cpu.cortex_m4 },

test/standalone/issue_11595/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
-// TODO integrate this with the std.build executor API
+// TODO integrate this with the std.Build executor API
 fn isRunnableTarget(t: CrossTarget) bool {
     if (t.isNative()) return true;
 
@@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
         t.getCpuArch() == builtin.cpu.arch);
 }
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/issue_12588/build.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
-const Builder = std.build.Builder;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/issue_12706/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
-// TODO integrate this with the std.build executor API
+// TODO integrate this with the std.Build executor API
 fn isRunnableTarget(t: CrossTarget) bool {
     if (t.isNative()) return true;
 
@@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
         t.getCpuArch() == builtin.cpu.arch);
 }
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/issue_13030/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/issue_339/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const obj = b.addObject(.{
         .name = "test",
         .root_source_file = .{ .path = "test.zig" },

test/standalone/issue_5825/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const target = .{
         .cpu_arch = .x86_64,
         .os_tag = .windows,

test/standalone/issue_7030/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const exe = b.addExecutable(.{
         .name = "issue_7030",
         .root_source_file = .{ .path = "main.zig" },

test/standalone/issue_794/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_artifact = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },
     });

test/standalone/issue_8550/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) !void {
+pub fn build(b: *std.Build) !void {
     const target = std.zig.CrossTarget{
         .os_tag = .freestanding,
         .cpu_arch = .arm,

test/standalone/issue_9812/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) !void {
+pub fn build(b: *std.Build) !void {
     const optimize = b.standardOptimizeOption(.{});
     const zip_add = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },

test/standalone/load_dynamic_library/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 

test/standalone/main_pkg_path/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_exe = b.addTest(.{
         .root_source_file = .{ .path = "a/test.zig" },
     });

test/standalone/mix_c_files/build.zig

@@ -1,9 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = std.build.Builder;
 const CrossTarget = std.zig.CrossTarget;
 
-// TODO integrate this with the std.build executor API
+// TODO integrate this with the std.Build executor API
 fn isRunnableTarget(t: CrossTarget) bool {
     if (t.isNative()) return true;
 
@@ -11,7 +10,7 @@ fn isRunnableTarget(t: CrossTarget) bool {
         t.getCpuArch() == builtin.cpu.arch);
 }
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 

test/standalone/mix_o_files/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const obj = b.addObject(.{

test/standalone/options/build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 

test/standalone/pie/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const main = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },
         .optimize = b.standardOptimizeOption(.{}),

test/standalone/pkg_import/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const exe = b.addExecutable(.{

test/standalone/shared_library/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
     const lib = b.addSharedLibrary(.{

test/standalone/static_c_lib/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const foo = b.addStaticLibrary(.{

test/standalone/test_runner_path/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const test_exe = b.addTest(.{
         .root_source_file = .{ .path = "test.zig" },
         .kind = .test_exe,

test/standalone/use_alias/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const main = b.addTest(.{
         .root_source_file = .{ .path = "main.zig" },
         .optimize = b.standardOptimizeOption(.{}),

test/standalone/windows_spawn/build.zig

@@ -1,6 +1,6 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
 
-pub fn build(b: *Builder) void {
+pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const hello = b.addExecutable(.{

test/tests.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const debug = std.debug;
-const build = std.build;
 const CrossTarget = std.zig.CrossTarget;
 const io = std.io;
 const fs = std.fs;
@@ -9,9 +8,10 @@ const mem = std.mem;
 const fmt = std.fmt;
 const ArrayList = std.ArrayList;
 const OptimizeMode = std.builtin.OptimizeMode;
-const LibExeObjStep = build.LibExeObjStep;
+const LibExeObjStep = std.Build.LibExeObjStep;
 const Allocator = mem.Allocator;
-const ExecError = build.Builder.ExecError;
+const ExecError = std.Build.ExecError;
+const Step = std.Build.Step;
 
 // Cases
 const compare_output = @import("compare_output.zig");
@@ -462,7 +462,7 @@ const test_targets = blk: {
 
 const max_stdout_size = 1 * 1024 * 1024; // 1 MB
 
-pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
+pub fn addCompareOutputTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
     const cases = b.allocator.create(CompareOutputContext) catch unreachable;
     cases.* = CompareOutputContext{
         .b = b,
@@ -477,7 +477,7 @@ pub fn addCompareOutputTests(b: *build.Builder, test_filter: ?[]const u8, optimi
     return cases.step;
 }
 
-pub fn addStackTraceTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
+pub fn addStackTraceTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
     const cases = b.allocator.create(StackTracesContext) catch unreachable;
     cases.* = StackTracesContext{
         .b = b,
@@ -493,7 +493,7 @@ pub fn addStackTraceTests(b: *build.Builder, test_filter: ?[]const u8, optimize_
 }
 
 pub fn addStandaloneTests(
-    b: *build.Builder,
+    b: *std.Build,
     test_filter: ?[]const u8,
     optimize_modes: []const OptimizeMode,
     skip_non_native: bool,
@@ -506,7 +506,7 @@ pub fn addStandaloneTests(
     enable_wasmtime: bool,
     enable_wine: bool,
     enable_symlinks_windows: bool,
-) *build.Step {
+) *Step {
     const cases = b.allocator.create(StandaloneContext) catch unreachable;
     cases.* = StandaloneContext{
         .b = b,
@@ -532,13 +532,13 @@ pub fn addStandaloneTests(
 }
 
 pub fn addLinkTests(
-    b: *build.Builder,
+    b: *std.Build,
     test_filter: ?[]const u8,
     optimize_modes: []const OptimizeMode,
     enable_macos_sdk: bool,
     omit_stage2: bool,
     enable_symlinks_windows: bool,
-) *build.Step {
+) *Step {
     const cases = b.allocator.create(StandaloneContext) catch unreachable;
     cases.* = StandaloneContext{
         .b = b,
@@ -556,7 +556,7 @@ pub fn addLinkTests(
     return cases.step;
 }
 
-pub fn addCliTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
+pub fn addCliTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
     _ = test_filter;
     _ = optimize_modes;
     const step = b.step("test-cli", "Test the command line interface");
@@ -577,7 +577,7 @@ pub fn addCliTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes:
     return step;
 }
 
-pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *build.Step {
+pub fn addAssembleAndLinkTests(b: *std.Build, test_filter: ?[]const u8, optimize_modes: []const OptimizeMode) *Step {
     const cases = b.allocator.create(CompareOutputContext) catch unreachable;
     cases.* = CompareOutputContext{
         .b = b,
@@ -592,7 +592,7 @@ pub fn addAssembleAndLinkTests(b: *build.Builder, test_filter: ?[]const u8, opti
     return cases.step;
 }
 
-pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
+pub fn addTranslateCTests(b: *std.Build, test_filter: ?[]const u8) *Step {
     const cases = b.allocator.create(TranslateCContext) catch unreachable;
     cases.* = TranslateCContext{
         .b = b,
@@ -607,10 +607,10 @@ pub fn addTranslateCTests(b: *build.Builder, test_filter: ?[]const u8) *build.St
 }
 
 pub fn addRunTranslatedCTests(
-    b: *build.Builder,
+    b: *std.Build,
     test_filter: ?[]const u8,
     target: std.zig.CrossTarget,
-) *build.Step {
+) *Step {
     const cases = b.allocator.create(RunTranslatedCContext) catch unreachable;
     cases.* = .{
         .b = b,
@@ -625,7 +625,7 @@ pub fn addRunTranslatedCTests(
     return cases.step;
 }
 
-pub fn addGenHTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
+pub fn addGenHTests(b: *std.Build, test_filter: ?[]const u8) *Step {
     const cases = b.allocator.create(GenHContext) catch unreachable;
     cases.* = GenHContext{
         .b = b,
@@ -640,7 +640,7 @@ pub fn addGenHTests(b: *build.Builder, test_filter: ?[]const u8) *build.Step {
 }
 
 pub fn addPkgTests(
-    b: *build.Builder,
+    b: *std.Build,
     test_filter: ?[]const u8,
     root_src: []const u8,
     name: []const u8,
@@ -651,7 +651,7 @@ pub fn addPkgTests(
     skip_libc: bool,
     skip_stage1: bool,
     skip_stage2: bool,
-) *build.Step {
+) *Step {
     const step = b.step(b.fmt("test-{s}", .{name}), desc);
 
     for (test_targets) |test_target| {
@@ -742,8 +742,8 @@ pub fn addPkgTests(
 }
 
 pub const StackTracesContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *Step,
     test_index: usize,
     test_filter: ?[]const u8,
     optimize_modes: []const OptimizeMode,
@@ -840,7 +840,7 @@ pub const StackTracesContext = struct {
     const RunAndCompareStep = struct {
         pub const base_id = .custom;
 
-        step: build.Step,
+        step: Step,
         context: *StackTracesContext,
         exe: *LibExeObjStep,
         name: []const u8,
@@ -858,7 +858,7 @@ pub const StackTracesContext = struct {
             const allocator = context.b.allocator;
             const ptr = allocator.create(RunAndCompareStep) catch unreachable;
             ptr.* = RunAndCompareStep{
-                .step = build.Step.init(.custom, "StackTraceCompareOutputStep", allocator, make),
+                .step = Step.init(.custom, "StackTraceCompareOutputStep", allocator, make),
                 .context = context,
                 .exe = exe,
                 .name = name,
@@ -871,7 +871,7 @@ pub const StackTracesContext = struct {
             return ptr;
         }
 
-        fn make(step: *build.Step) !void {
+        fn make(step: *Step) !void {
             const self = @fieldParentPtr(RunAndCompareStep, "step", step);
             const b = self.context.b;
 
@@ -1014,8 +1014,8 @@ pub const StackTracesContext = struct {
 };
 
 pub const StandaloneContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *Step,
     test_index: usize,
     test_filter: ?[]const u8,
     optimize_modes: []const OptimizeMode,
@@ -1150,8 +1150,8 @@ pub const StandaloneContext = struct {
 };
 
 pub const GenHContext = struct {
-    b: *build.Builder,
+    b: *std.Build,
-    step: *build.Step,
+    step: *Step,
     test_index: usize,
     test_filter: ?[]const u8,
 
@@ -1178,7 +1178,7 @@ pub const GenHContext = struct {
     };
 
     const GenHCmpOutputStep = struct {
-        step: build.Step,
+        step: Step,
         context: *GenHContext,
         obj: *LibExeObjStep,
         name: []const u8,
@@ -1194,7 +1194,7 @@ pub const GenHContext = struct {
             const allocator = context.b.allocator;
             const ptr = allocator.create(GenHCmpOutputStep) catch unreachable;
             ptr.* = GenHCmpOutputStep{
-                .step = build.Step.init(.Custom, "ParseCCmpOutput", allocator, make),
+                .step = Step.init(.Custom, "ParseCCmpOutput", allocator, make),
                 .context = context,
                 .obj = obj,
                 .name = name,
@@ -1206,7 +1206,7 @@ pub const GenHContext = struct {
             return ptr;
         }
 
-        fn make(step: *build.Step) !void {
+        fn make(step: *Step) !void {
             const self = @fieldParentPtr(GenHCmpOutputStep, "step", step);
             const b = self.context.b;
 
@@ -1348,7 +1348,7 @@ const c_abi_targets = [_]CrossTarget{
     },
 };
 
-pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool, skip_release: bool) *build.Step {
+pub fn addCAbiTests(b: *std.Build, skip_non_native: bool, skip_release: bool) *Step {
     const step = b.step("test-c-abi", "Run the C ABI tests");
 
     const optimize_modes: [2]OptimizeMode = .{ .Debug, .ReleaseFast };