const std = @import("std");
const meta = std.meta;
const mem = std.mem;

pub const Data = struct {
    foo: ?[]const u8 = null,
};

export fn do_something() void {
    var data: Data = mem.zeroes(Data);

    populate(&data) catch unreachable;
    std.debug.print("bug: {any}\n", .{data});
}

fn populate(dest: anytype) !void {
    const T = @TypeOf(dest.*);
    switch (@typeInfo(T)) {
        .Struct => {
            const key = "foo";

            inline for (comptime meta.fieldNames(T)) |n| {
                if (mem.eql(u8, n, key)) {
                    try populate(
                        &@field(dest, n),
                    );
                }
            }
        },
        .Optional => |O| {
            dest.* = mem.zeroes(O.child);
            try populate(&dest.*.?);
            return;
        },
        .Pointer => |ptr_info| {
            switch (ptr_info.size) {
                .Slice => {
                    if (ptr_info.child == u8) {
                        dest.* = "hello";
                    }
                    return;
                },
                else => return error.UnsupportedType,
            }
        },
        else => return error.UnsupportedType,
    }
}

const std = @import("std");

pub fn build(b: *std.Build) void {
    const optimize = b.standardOptimizeOption(.{
        .preferred_optimize_mode = .ReleaseSafe,
    });

    const step = b.step("lib", "Compile library");

    const lib = b.addSharedLibrary(.{
        .name = "testlib",
        .root_source_file = .{ .path = "./src/main.zig" },
        .optimize = optimize,
        .target = .{},
    });

    lib.install();
    lib.linkLibC();
    step.dependOn(&lib.step);
}