addPackageOptionFromArg

fn addPackageOptionFromArg(
    arena: Allocator,
    map: *PackageOptions.Map,
    field_name: [:0]const u8,
    comptime T: type,
    /// If null, the value won't be added, but `T` will still be type-checked.
    maybe_value: ?T,
) void {
    map.ensureUnusedCapacity(arena, 2) catch @panic("OOM");
    switch (T) {
        Target.Query => return if (maybe_value) |v| {
            map.putAssumeCapacity(field_name, .{ .scalar = v.zigTriple(arena) catch @panic("OOM") });
            map.putAssumeCapacity("cpu", .{ .scalar = v.serializeCpuAlloc(arena) catch @panic("OOM") });
        },
        ResolvedTarget => return if (maybe_value) |v| {
            map.putAssumeCapacity(field_name, .{ .scalar = v.query.zigTriple(arena) catch @panic("OOM") });
            map.putAssumeCapacity("cpu", .{ .scalar = v.query.serializeCpuAlloc(arena) catch @panic("OOM") });
        },
        std.zig.BuildId => return if (maybe_value) |v| {
            map.putAssumeCapacity(field_name, .{
                .scalar = std.fmt.allocPrint(arena, "{f}", .{v}) catch @panic("OOM"),
            });
        },
        LazyPath => return if (maybe_value) |v| {
            map.putAssumeCapacity(field_name, .{ .lazy_path = v.dupeInner(arena) });
        },
        []const LazyPath => return if (maybe_value) |v| {
            var list: std.ArrayList(LazyPath) = .empty;
            const elems = list.addManyAsSlice(arena, v.len) catch @panic("OOM");
            for (v, elems) |lp, *elem| elem.* = lp.dupeInner(arena);
            map.putAssumeCapacity(field_name, .{ .lazy_path_list = list });
        },
        []const u8 => return if (maybe_value) |v| {
            map.putAssumeCapacity(field_name, .{ .scalar = arena.dupe(u8, v) catch @panic("OOM") });
        },
        []const []const u8 => return if (maybe_value) |v| {
            var list: std.ArrayList([]const u8) = .empty;
            const elems = list.addManyAsSlice(arena, v.len) catch @panic("OOM");
            for (v, elems) |s, *elem| elem.* = arena.dupe(u8, s) catch @panic("OOM");
            map.putAssumeCapacity(field_name, .{ .list = list });
        },
        else => switch (@typeInfo(T)) {
            .bool => return if (maybe_value) |v| {
                map.putAssumeCapacity(field_name, .{ .scalar = if (v) "true" else "false" });
            },
            .@"enum", .enum_literal => return if (maybe_value) |v| {
                map.putAssumeCapacity(field_name, .{ .scalar = @tagName(v) });
            },
            .comptime_int, .int => return if (maybe_value) |v| {
                map.putAssumeCapacity(field_name, .{
                    .scalar = std.fmt.allocPrint(arena, "{d}", .{v}) catch @panic("OOM"),
                });
            },
            .comptime_float, .float => return if (maybe_value) |v| {
                map.putAssumeCapacity(field_name, .{
                    .scalar = std.fmt.allocPrint(arena, "{x}", .{v}) catch @panic("OOM"),
                });
            },
            .pointer => |ptr_info| switch (ptr_info.size) {
                .one => switch (@typeInfo(ptr_info.child)) {
                    .array => |array_info| return addPackageOptionFromArg(
                        arena,
                        map,
                        field_name,
                        @Pointer(.slice, .{ .@"const" = true }, array_info.child, null),
                        maybe_value orelse null,
                    ),
                    else => {},
                },
                .slice => switch (@typeInfo(ptr_info.child)) {
                    .@"enum" => return if (maybe_value) |v| {
                        var list: std.ArrayList([]const u8) = .empty;
                        const elems = list.addManyAsSlice(arena, v.len) catch @panic("OOM");
                        for (elems, v) |*elem, tag| elem.* = @tagName(tag);
                        map.putAssumeCapacity(field_name, .{ .list = list });
                    },
                    else => return addPackageOptionFromArg(
                        arena,
                        map,
                        field_name,
                        @Pointer(ptr_info.size, .{ .@"const" = true }, ptr_info.child, null),
                        maybe_value orelse null,
                    ),
                },
                else => {},
            },
            .null => unreachable,
            .optional => |info| switch (@typeInfo(info.child)) {
                .optional => {},
                else => return addPackageOptionFromArg(arena, map, field_name, info.child, maybe_value orelse null),
            },
            else => {},
        },
    }
    @compileError("option '" ++ field_name ++ "' has unsupported type: " ++ @typeName(T));
}