zig build: use orelse to fetch next argument

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

1 files changed, 149 insertions, 115 deletions

diff --git a/src/main.zig b/src/main.zig
index 5e012ed067..fa9ce18c78 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -770,7 +770,7 @@ fn buildOutputType(
             _ = process_args_iter.skip(); // e.g. "build-lib"
             var resp_file_args_iter: ?ArgIteratorResponseFile = null;
 
-            var getNextArg = (struct {
+            const getNextArg = (struct {
                 pub fn getNextArg(_process_args_iter: *process.ArgIterator, maybe_resp_file_args_iter: *?ArgIteratorResponseFile) ?[:0]const u8 {
                     if (_process_args_iter.next()) |proc_arg| return proc_arg;
                     if (maybe_resp_file_args_iter.*) |*iter| return iter.next();
@@ -822,45 +822,49 @@ fn buildOutputType(
                         cur_pkg = cur_pkg.parent orelse
                             fatal("encountered --pkg-end with no matching --pkg-begin", .{});
                     } else if (mem.eql(u8, arg, "--main-pkg-path")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        main_pkg_path = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        main_pkg_path = next_arg;
                     } else if (mem.eql(u8, arg, "-cflags")) {
                         extra_cflags.shrinkRetainingCapacity(0);
                         while (true) {
-                            const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                            if (next_arg == null) fatal("expected -- after -cflags", .{});
-                            if (mem.eql(u8, next_arg.?, "--")) break;
-                            try extra_cflags.append(next_arg.?);
+                            const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                                fatal("expected -- after -cflags", .{});
+                            };
+                            if (mem.eql(u8, next_arg, "--")) break;
+                            try extra_cflags.append(next_arg);
                         }
                     } else if (mem.eql(u8, arg, "--color")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected [auto|on|off] after --color", .{});
-                        color = std.meta.stringToEnum(Color, next_arg.?) orelse {
-                            fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg.?});
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected [auto|on|off] after --color", .{});
+                        };
+                        color = std.meta.stringToEnum(Color, next_arg) orelse {
+                            fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg});
                         };
                     } else if (mem.eql(u8, arg, "--subsystem")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        if (mem.eql(u8, next_arg.?, "console")) {
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        if (mem.eql(u8, next_arg, "console")) {
                             subsystem = .Console;
-                        } else if (mem.eql(u8, next_arg.?, "windows")) {
+                        } else if (mem.eql(u8, next_arg, "windows")) {
                             subsystem = .Windows;
-                        } else if (mem.eql(u8, next_arg.?, "posix")) {
+                        } else if (mem.eql(u8, next_arg, "posix")) {
                             subsystem = .Posix;
-                        } else if (mem.eql(u8, next_arg.?, "native")) {
+                        } else if (mem.eql(u8, next_arg, "native")) {
                             subsystem = .Native;
-                        } else if (mem.eql(u8, next_arg.?, "efi_application")) {
+                        } else if (mem.eql(u8, next_arg, "efi_application")) {
                             subsystem = .EfiApplication;
-                        } else if (mem.eql(u8, next_arg.?, "efi_boot_service_driver")) {
+                        } else if (mem.eql(u8, next_arg, "efi_boot_service_driver")) {
                             subsystem = .EfiBootServiceDriver;
-                        } else if (mem.eql(u8, next_arg.?, "efi_rom")) {
+                        } else if (mem.eql(u8, next_arg, "efi_rom")) {
                             subsystem = .EfiRom;
-                        } else if (mem.eql(u8, next_arg.?, "efi_runtime_driver")) {
+                        } else if (mem.eql(u8, next_arg, "efi_runtime_driver")) {
                             subsystem = .EfiRuntimeDriver;
                         } else {
                             fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{
-                                next_arg.?,
+                                next_arg,
                                 \\  console
                                 \\  windows
                                 \\  posix
@@ -873,67 +877,81 @@ fn buildOutputType(
                             });
                         }
                     } else if (mem.eql(u8, arg, "-O")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        optimize_mode_string = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        optimize_mode_string = next_arg;
                     } else if (mem.eql(u8, arg, "--entry")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        entry = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        entry = next_arg;
                     } else if (mem.eql(u8, arg, "--stack")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        stack_size_override = std.fmt.parseUnsigned(u64, next_arg.?, 0) catch |err| {
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
                             fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
                         };
                     } else if (mem.eql(u8, arg, "--image-base")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        image_base_override = std.fmt.parseUnsigned(u64, next_arg.?, 0) catch |err| {
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
                             fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
                         };
                     } else if (mem.eql(u8, arg, "--name")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        provided_name = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        provided_name = next_arg;
                     } else if (mem.eql(u8, arg, "-rpath")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try rpath_list.append(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try rpath_list.append(next_arg);
                     } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try lib_dirs.append(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try lib_dirs.append(next_arg);
                     } else if (mem.eql(u8, arg, "-F")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try framework_dirs.append(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try framework_dirs.append(next_arg);
                     } else if (mem.eql(u8, arg, "-framework")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try frameworks.append(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try frameworks.append(next_arg);
                     } else if (mem.eql(u8, arg, "-install_name")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        install_name = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        install_name = next_arg;
                     } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        linker_script = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        linker_script = next_arg;
                     } else if (mem.eql(u8, arg, "--version-script")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        version_script = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        version_script = next_arg;
                     } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
                         // We don't know whether this library is part of libc or libc++ until
                         // we resolve the target, so we simply append to the list for now.
-                        try system_libs.put(next_arg.?, .{ .needed = false });
+                        try system_libs.put(next_arg, .{ .needed = false });
                     } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try system_libs.put(next_arg.?, .{ .needed = true });
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try system_libs.put(next_arg, .{ .needed = true });
                     } else if (mem.eql(u8, arg, "-D") or
                         mem.eql(u8, arg, "-isystem") or
                         mem.eql(u8, arg, "-I") or
@@ -942,29 +960,34 @@ fn buildOutputType(
                         mem.eql(u8, arg, "-iframework") or
                         mem.eql(u8, arg, "-iframeworkwithsysroot"))
                     {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
                         try clang_argv.append(arg);
-                        try clang_argv.append(next_arg.?);
+                        try clang_argv.append(next_arg);
                     } else if (mem.eql(u8, arg, "--version")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after --version", .{});
-                        version = std.builtin.Version.parse(next_arg.?) catch |err| {
-                            fatal("unable to parse --version '{s}': {s}", .{ next_arg.?, @errorName(err) });
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        version = std.builtin.Version.parse(next_arg) catch |err| {
+                            fatal("unable to parse --version '{s}': {s}", .{ next_arg, @errorName(err) });
                         };
                         have_version = true;
                     } else if (mem.eql(u8, arg, "-target")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        target_arch_os_abi = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        target_arch_os_abi = next_arg;
                     } else if (mem.eql(u8, arg, "-mcpu")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        target_mcpu = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        target_mcpu = next_arg;
                     } else if (mem.eql(u8, arg, "-mcmodel")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        machine_code_model = parseCodeModel(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        machine_code_model = parseCodeModel(next_arg);
                     } else if (mem.startsWith(u8, arg, "-ofmt=")) {
                         target_ofmt = arg["-ofmt=".len..];
                     } else if (mem.startsWith(u8, arg, "-mcpu=")) {
@@ -974,50 +997,60 @@ fn buildOutputType(
                     } else if (mem.startsWith(u8, arg, "-O")) {
                         optimize_mode_string = arg["-O".len..];
                     } else if (mem.eql(u8, arg, "--dynamic-linker")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        target_dynamic_linker = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        target_dynamic_linker = next_arg;
                     } else if (mem.eql(u8, arg, "--sysroot")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        sysroot = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        sysroot = next_arg;
                         try clang_argv.append("-isysroot");
-                        try clang_argv.append(next_arg.?);
+                        try clang_argv.append(next_arg);
                     } else if (mem.eql(u8, arg, "--libc")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        libc_paths_file = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        libc_paths_file = next_arg;
                     } else if (mem.eql(u8, arg, "--test-filter")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        test_filter = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        test_filter = next_arg;
                     } else if (mem.eql(u8, arg, "--test-name-prefix")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        test_name_prefix = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        test_name_prefix = next_arg;
                     } else if (mem.eql(u8, arg, "--test-cmd")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        try test_exec_args.append(next_arg.?);
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        try test_exec_args.append(next_arg);
                     } else if (mem.eql(u8, arg, "--cache-dir")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        override_local_cache_dir = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        override_local_cache_dir = next_arg;
                     } else if (mem.eql(u8, arg, "--global-cache-dir")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        override_global_cache_dir = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        override_global_cache_dir = next_arg;
                     } else if (mem.eql(u8, arg, "--zig-lib-dir")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
-                        override_lib_dir = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        override_lib_dir = next_arg;
                     } else if (mem.eql(u8, arg, "--debug-log")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected parameter after {s}", .{arg});
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
                         if (!build_options.enable_logging) {
                             std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});
                         } else {
-                            try log_scopes.append(gpa, next_arg.?);
+                            try log_scopes.append(gpa, next_arg);
                         }
                     } else if (mem.eql(u8, arg, "--debug-link-snapshot")) {
                         if (!build_options.enable_link_snapshots) {
@@ -1190,9 +1223,10 @@ fn buildOutputType(
                     } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {
                         linker_allow_shlib_undefined = false;
                     } else if (mem.eql(u8, arg, "-z")) {
-                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter);
-                        if (next_arg == null) fatal("expected linker extension flag after '{s}'", .{arg});
-                        const z_arg = next_arg.?;
+                        const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse {
+                            fatal("expected parameter after {s}", .{arg});
+                        };
+                        const z_arg = next_arg;
                         if (mem.eql(u8, z_arg, "nodelete")) {
                             linker_z_nodelete = true;
                         } else if (mem.eql(u8, z_arg, "notext")) {