update arocc and import it in a way that respects its build script

this also patches some functions to be pub

Author: andrewrk

arocc/build.zig

@@ -1,16 +1,19 @@
 const std = @import("std");
-const Builder = std.build.Builder;
-
-fn addFuzzStep(b: *Builder, target: std.zig.CrossTarget) !void {
-    const fuzz_lib = b.addStaticLibrary("fuzz-lib", "test/fuzz/fuzz_lib.zig");
-    fuzz_lib.addPackagePath("aro", "src/lib.zig");
-    fuzz_lib.setTarget(target);
-    fuzz_lib.setBuildMode(.Debug);
+const Build = std.Build;
+
+fn addFuzzStep(b: *Build, target: std.zig.CrossTarget) !void {
+    const fuzz_lib = b.addStaticLibrary(.{
+        .name = "fuzz-lib",
+        .target = target,
+        .optimize = .Debug,
+        .root_source_file = .{ .path = "test/fuzz/fuzz_lib.zig" },
+    });
+    fuzz_lib.addAnonymousModule("aro", .{ .source_file = .{ .path = "src/lib.zig" } });
     fuzz_lib.want_lto = true;
     fuzz_lib.bundle_compiler_rt = true;
 
     const fuzz_executable_name = "fuzz";
-    const fuzz_exe_path = try std.fs.path.join(b.allocator, &.{ b.cache_root, fuzz_executable_name });
+    const fuzz_exe_path = try b.cache_root.join(b.allocator, &.{fuzz_executable_name});
 
     // We want `afl-clang-lto -o path/to/output test/fuzz/main.c path/to/library`
     const fuzz_compile = b.addSystemCommand(&.{ "afl-clang-lto", "-o", fuzz_exe_path, "test/fuzz/main.c" });
@@ -26,7 +29,7 @@ fn addFuzzStep(b: *Builder, target: std.zig.CrossTarget) !void {
     fuzz_compile_run.dependOn(&fuzz_install.step);
 }
 
-pub fn build(b: *Builder) !void {
+pub fn build(b: *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
@@ -35,20 +38,31 @@ pub fn build(b: *Builder) !void {
 
     // Standard release options allow the person running `zig build` to select
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    const mode = b.standardOptimizeOption(.{});
 
     const test_all_allocation_failures = b.option(bool, "test-all-allocation-failures", "Test all allocation failures") orelse false;
     const link_libc = b.option(bool, "link-libc", "Force self-hosted compiler to link libc") orelse (mode != .Debug);
     const tracy = b.option([]const u8, "tracy", "Enable Tracy integration. Supply path to Tracy source");
     const tracy_callstack = b.option(bool, "tracy-callstack", "Include callstack information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
     const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
 
-    const zig_pkg = std.build.Pkg{
-        .name = "zig",
-        .source = .{ .path = "deps/zig/lib.zig" },
-    };
+    const zig_module = b.createModule(.{
+        .source_file = .{ .path = "deps/zig/lib.zig" },
+    });
+    const aro_module = b.addModule("aro", .{
+        .source_file = .{ .path = "src/lib.zig" },
+        .dependencies = &.{.{
+            .name = "zig",
+            .module = zig_module,
+        }},
+    });
 
-    const exe = b.addExecutable("arocc", "src/main.zig");
+    const exe = b.addExecutable(.{
+        .name = "arocc",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .optimize = mode,
+        .target = target,
+    });
     const exe_options = b.addOptions();
     exe.addOptions("build_options", exe_options);
     exe_options.addOption(bool, "enable_tracy", tracy != null);
@@ -76,52 +90,38 @@ pub fn build(b: *Builder) !void {
             exe.linkSystemLibrary("ws2_32");
         }
     }
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
-    exe.addPackage(zig_pkg);
+    exe.addModule("zig", zig_module);
     if (link_libc) {
         exe.linkLibC();
     }
-    exe.install();
-
-    const run_cmd = exe.run();
-    run_cmd.expected_exit_code = null;
-    run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
-        run_cmd.addArgs(args);
-    }
-
-    const run_step = b.step("run", "Run the app");
-    run_step.dependOn(&run_cmd.step);
+    b.installArtifact(exe);
 
     const tests_step = b.step("test", "Run all tests");
     tests_step.dependOn(&exe.step);
 
-    var unit_tests = b.addTest("src/main.zig");
-    unit_tests.addPackage(zig_pkg);
+    var unit_tests = b.addTest(.{ .root_source_file = .{ .path = "src/main.zig" } });
+    unit_tests.addModule("zig", zig_module);
     tests_step.dependOn(&unit_tests.step);
 
-    const integration_tests = b.addExecutable("arocc", "test/runner.zig");
-    integration_tests.addPackage(.{
-        .name = "aro",
-        .source = .{ .path = "src/lib.zig" },
-        .dependencies = &.{zig_pkg},
+    const integration_tests = b.addExecutable(.{
+        .name = "test-runner",
+        .root_source_file = .{ .path = "test/runner.zig" },
     });
+    integration_tests.addModule("aro", aro_module);
     const test_runner_options = b.addOptions();
     integration_tests.addOptions("build_options", test_runner_options);
     test_runner_options.addOption(bool, "test_all_allocation_failures", test_all_allocation_failures);
 
-    const integration_test_runner = integration_tests.run();
+    const integration_test_runner = b.addRunArtifact(integration_tests);
     integration_test_runner.addArg(b.pathFromRoot("test/cases"));
     integration_test_runner.addArg(b.zig_exe);
 
-    const record_tests = b.addExecutable("arocc", "test/record_runner.zig");
-    record_tests.addPackage(.{
-        .name = "aro",
-        .source = .{ .path = "src/lib.zig" },
-        .dependencies = &.{zig_pkg},
+    const record_tests = b.addExecutable(.{
+        .name = "test-runner",
+        .root_source_file = .{ .path = "test/record_runner.zig" },
     });
-    const record_tests_runner = record_tests.run();
+    record_tests.addModule("aro", aro_module);
+    const record_tests_runner = b.addRunArtifact(record_tests);
     record_tests_runner.addArg(b.pathFromRoot("test/records"));
     record_tests_runner.addArg(b.zig_exe);