From 5380e81924dd98e9717eaf09ae05e935952a78ff Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Sun, 23 Mar 2025 22:45:38 +0100 Subject: Support passing null to `b.dependency()` Both null literals and optionals are supported. --- lib/std/Build.zig | 179 ++++++++++++++++++++++++++++++------------------------ 1 file changed, 101 insertions(+), 78 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index e65a71e12b..e5b9e072f7 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -408,104 +408,127 @@ fn createChildOnly( return child; } -fn userInputOptionsFromArgs(allocator: Allocator, args: anytype) UserInputOptionsMap { - var user_input_options = UserInputOptionsMap.init(allocator); +fn userInputOptionsFromArgs(arena: Allocator, args: anytype) UserInputOptionsMap { + var map = UserInputOptionsMap.init(arena); inline for (@typeInfo(@TypeOf(args)).@"struct".fields) |field| { - const v = @field(args, field.name); - const T = @TypeOf(v); - switch (T) { - Target.Query => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = v.zigTriple(allocator) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); - user_input_options.put("cpu", .{ - .name = "cpu", - .value = .{ .scalar = v.serializeCpuAlloc(allocator) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); - }, - ResolvedTarget => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = v.query.zigTriple(allocator) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); - user_input_options.put("cpu", .{ - .name = "cpu", - .value = .{ .scalar = v.query.serializeCpuAlloc(allocator) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); - }, - LazyPath => { - user_input_options.put(field.name, .{ + if (field.type == @Type(.null)) continue; + addUserInputOptionFromArg(arena, &map, field, field.type, @field(args, field.name)); + } + return map; +} + +fn addUserInputOptionFromArg( + arena: Allocator, + map: *UserInputOptionsMap, + field: std.builtin.Type.StructField, + comptime T: type, + /// If null, the value won't be added, but `T` will still be type-checked. + maybe_value: ?T, +) void { + switch (T) { + Target.Query => return if (maybe_value) |v| { + map.put(field.name, .{ + .name = field.name, + .value = .{ .scalar = v.zigTriple(arena) catch @panic("OOM") }, + .used = false, + }) catch @panic("OOM"); + map.put("cpu", .{ + .name = "cpu", + .value = .{ .scalar = v.serializeCpuAlloc(arena) catch @panic("OOM") }, + .used = false, + }) catch @panic("OOM"); + }, + ResolvedTarget => return if (maybe_value) |v| { + map.put(field.name, .{ + .name = field.name, + .value = .{ .scalar = v.query.zigTriple(arena) catch @panic("OOM") }, + .used = false, + }) catch @panic("OOM"); + map.put("cpu", .{ + .name = "cpu", + .value = .{ .scalar = v.query.serializeCpuAlloc(arena) catch @panic("OOM") }, + .used = false, + }) catch @panic("OOM"); + }, + LazyPath => return if (maybe_value) |v| { + map.put(field.name, .{ + .name = field.name, + .value = .{ .lazy_path = v.dupeInner(arena) }, + .used = false, + }) catch @panic("OOM"); + }, + []const LazyPath => return if (maybe_value) |v| { + var list = ArrayList(LazyPath).initCapacity(arena, v.len) catch @panic("OOM"); + for (v) |lp| list.appendAssumeCapacity(lp.dupeInner(arena)); + map.put(field.name, .{ + .name = field.name, + .value = .{ .lazy_path_list = list }, + .used = false, + }) catch @panic("OOM"); + }, + []const u8 => return if (maybe_value) |v| { + map.put(field.name, .{ + .name = field.name, + .value = .{ .scalar = v }, + .used = false, + }) catch @panic("OOM"); + }, + []const []const u8 => return if (maybe_value) |v| { + var list = ArrayList([]const u8).initCapacity(arena, v.len) catch @panic("OOM"); + list.appendSliceAssumeCapacity(v); + map.put(field.name, .{ + .name = field.name, + .value = .{ .list = list }, + .used = false, + }) catch @panic("OOM"); + }, + else => switch (@typeInfo(T)) { + .bool => return if (maybe_value) |v| { + map.put(field.name, .{ .name = field.name, - .value = .{ .lazy_path = v.dupeInner(allocator) }, + .value = .{ .scalar = if (v) "true" else "false" }, .used = false, }) catch @panic("OOM"); }, - []const LazyPath => { - var list = ArrayList(LazyPath).initCapacity(allocator, v.len) catch @panic("OOM"); - for (v) |lp| list.appendAssumeCapacity(lp.dupeInner(allocator)); - user_input_options.put(field.name, .{ + .@"enum", .enum_literal => return if (maybe_value) |v| { + map.put(field.name, .{ .name = field.name, - .value = .{ .lazy_path_list = list }, + .value = .{ .scalar = @tagName(v) }, .used = false, }) catch @panic("OOM"); }, - []const u8 => { - user_input_options.put(field.name, .{ + .comptime_int, .int => return if (maybe_value) |v| { + map.put(field.name, .{ .name = field.name, - .value = .{ .scalar = v }, + .value = .{ .scalar = std.fmt.allocPrint(arena, "{d}", .{v}) catch @panic("OOM") }, .used = false, }) catch @panic("OOM"); }, - []const []const u8 => { - var list = ArrayList([]const u8).initCapacity(allocator, v.len) catch @panic("OOM"); - list.appendSliceAssumeCapacity(v); - - user_input_options.put(field.name, .{ + .comptime_float, .float => return if (maybe_value) |v| { + map.put(field.name, .{ .name = field.name, - .value = .{ .list = list }, + .value = .{ .scalar = std.fmt.allocPrint(arena, "{e}", .{v}) catch @panic("OOM") }, .used = false, }) catch @panic("OOM"); }, - else => switch (@typeInfo(T)) { - .bool => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = if (v) "true" else "false" }, - .used = false, - }) catch @panic("OOM"); - }, - .@"enum", .enum_literal => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = @tagName(v) }, - .used = false, - }) catch @panic("OOM"); - }, - .comptime_int, .int => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = std.fmt.allocPrint(allocator, "{d}", .{v}) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); + .null => unreachable, + .optional => |info| switch (@typeInfo(info.child)) { + .optional => {}, + else => { + addUserInputOptionFromArg( + arena, + map, + field, + info.child, + maybe_value orelse null, + ); + return; }, - .comptime_float, .float => { - user_input_options.put(field.name, .{ - .name = field.name, - .value = .{ .scalar = std.fmt.allocPrint(allocator, "{e}", .{v}) catch @panic("OOM") }, - .used = false, - }) catch @panic("OOM"); - }, - else => @compileError("option '" ++ field.name ++ "' has unsupported type: " ++ @typeName(T)), }, - } + else => {}, + }, } - - return user_input_options; + @compileError("option '" ++ field.name ++ "' has unsupported type: " ++ @typeName(field.type)); } const OrderedUserValue = union(enum) { -- cgit v1.2.3 From e7604bba3ef0654a882edb17d712d1beb2cefec9 Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Mon, 24 Mar 2025 13:22:08 +0100 Subject: Serialize float options using the hexadecimal format This ensures no information is lost when the value is round-tripped. --- lib/std/Build.zig | 2 +- lib/std/Io/Writer.zig | 16 +++++++++++----- 2 files changed, 12 insertions(+), 6 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index e5b9e072f7..1c73767009 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -507,7 +507,7 @@ fn addUserInputOptionFromArg( .comptime_float, .float => return if (maybe_value) |v| { map.put(field.name, .{ .name = field.name, - .value = .{ .scalar = std.fmt.allocPrint(arena, "{e}", .{v}) catch @panic("OOM") }, + .value = .{ .scalar = std.fmt.allocPrint(arena, "{x}", .{v}) catch @panic("OOM") }, .used = false, }) catch @panic("OOM"); }, diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig index 09a1c8f81b..1a717f0bca 100644 --- a/lib/std/Io/Writer.zig +++ b/lib/std/Io/Writer.zig @@ -1563,17 +1563,23 @@ pub fn printFloatHexOptions(w: *Writer, value: anytype, options: std.fmt.Number) } pub fn printFloatHex(w: *Writer, value: anytype, case: std.fmt.Case, opt_precision: ?usize) Error!void { - if (std.math.signbit(value)) try w.writeByte('-'); - if (std.math.isNan(value)) return w.writeAll(switch (case) { + const v = switch (@TypeOf(value)) { + // comptime_float internally is a f128; this preserves precision. + comptime_float => @as(f128, value), + else => value, + }; + + if (std.math.signbit(v)) try w.writeByte('-'); + if (std.math.isNan(v)) return w.writeAll(switch (case) { .lower => "nan", .upper => "NAN", }); - if (std.math.isInf(value)) return w.writeAll(switch (case) { + if (std.math.isInf(v)) return w.writeAll(switch (case) { .lower => "inf", .upper => "INF", }); - const T = @TypeOf(value); + const T = @TypeOf(v); const TU = std.meta.Int(.unsigned, @bitSizeOf(T)); const mantissa_bits = std.math.floatMantissaBits(T); @@ -1583,7 +1589,7 @@ pub fn printFloatHex(w: *Writer, value: anytype, case: std.fmt.Case, opt_precisi const exponent_mask = (1 << exponent_bits) - 1; const exponent_bias = (1 << (exponent_bits - 1)) - 1; - const as_bits: TU = @bitCast(value); + const as_bits: TU = @bitCast(v); var mantissa = as_bits & mantissa_mask; var exponent: i32 = @as(u16, @truncate((as_bits >> mantissa_bits) & exponent_mask)); -- cgit v1.2.3 From 1a9fae2a70371fdbd77446fd5173162bfa065624 Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Mon, 24 Mar 2025 13:25:56 +0100 Subject: Dupe string options --- lib/std/Build.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 1c73767009..21eb5196ed 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -469,13 +469,13 @@ fn addUserInputOptionFromArg( []const u8 => return if (maybe_value) |v| { map.put(field.name, .{ .name = field.name, - .value = .{ .scalar = v }, + .value = .{ .scalar = arena.dupe(u8, v) catch @panic("OOM") }, .used = false, }) catch @panic("OOM"); }, []const []const u8 => return if (maybe_value) |v| { var list = ArrayList([]const u8).initCapacity(arena, v.len) catch @panic("OOM"); - list.appendSliceAssumeCapacity(v); + for (v) |s| list.appendAssumeCapacity(arena.dupe(u8, s) catch @panic("OOM")); map.put(field.name, .{ .name = field.name, .value = .{ .list = list }, -- cgit v1.2.3 From fd5eba9358ebf2f498b7c35bae34267f06d070d2 Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Mon, 24 Mar 2025 00:01:28 +0100 Subject: Coerce slice-like arguments passed to `b.dependency()` You can now pass string literals as options. --- lib/std/Build.zig | 34 ++++++++++++++++++ test/standalone/dependency_options/build.zig | 53 ++++++++++++++++++++++------ 2 files changed, 76 insertions(+), 11 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 21eb5196ed..efff88b469 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -511,6 +511,40 @@ fn addUserInputOptionFromArg( .used = false, }) catch @panic("OOM"); }, + .pointer => |ptr_info| switch (ptr_info.size) { + .one => switch (@typeInfo(ptr_info.child)) { + .array => |array_info| { + comptime var slice_info = ptr_info; + slice_info.size = .slice; + slice_info.is_const = true; + slice_info.child = array_info.child; + slice_info.sentinel_ptr = null; + addUserInputOptionFromArg( + arena, + map, + field, + @Type(.{ .pointer = slice_info }), + maybe_value orelse null, + ); + return; + }, + else => {}, + }, + .slice => { + comptime var slice_info = ptr_info; + slice_info.is_const = true; + slice_info.sentinel_ptr = null; + addUserInputOptionFromArg( + arena, + map, + field, + @Type(.{ .pointer = slice_info }), + maybe_value orelse null, + ); + return; + }, + else => {}, + }, .null => unreachable, .optional => |info| switch (@typeInfo(info.child)) { .optional => {}, diff --git a/test/standalone/dependency_options/build.zig b/test/standalone/dependency_options/build.zig index 27ce63834d..351a82ccdb 100644 --- a/test/standalone/dependency_options/build.zig +++ b/test/standalone/dependency_options/build.zig @@ -81,25 +81,56 @@ pub fn build(b: *std.Build) !void { if (all_specified_optional != all_specified) return error.TestFailed; + const all_specified_literal = b.dependency("other", .{ + .target = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu }), + .optimize = .ReleaseSafe, + .bool = true, + .int = 123, + .float = 0.5, + .string = "abc", + .string_list = &[_][]const u8{ "a", "b", "c" }, + .lazy_path = @as(std.Build.LazyPath, .{ .cwd_relative = "abc.txt" }), + .lazy_path_list = &[_]std.Build.LazyPath{ + .{ .cwd_relative = "a.txt" }, + .{ .cwd_relative = "b.txt" }, + .{ .cwd_relative = "c.txt" }, + }, + .@"enum" = .alfa, + //.enum_list = &[_]Enum{ .alfa, .bravo, .charlie }, + //.build_id = @as(std.zig.BuildId, .uuid), + }); + + if (all_specified_literal != all_specified) return error.TestFailed; + + var mut_string_buf = "abc".*; + const mut_string: []u8 = &mut_string_buf; + var mut_string_list_buf = [_][]const u8{ "a", "b", "c" }; + const mut_string_list: [][]const u8 = &mut_string_list_buf; + var mut_lazy_path_list_buf = [_]std.Build.LazyPath{ + .{ .cwd_relative = "a.txt" }, + .{ .cwd_relative = "b.txt" }, + .{ .cwd_relative = "c.txt" }, + }; + const mut_lazy_path_list: []std.Build.LazyPath = &mut_lazy_path_list_buf; + var mut_enum_list_buf = [_]Enum{ .alfa, .bravo, .charlie }; + const mut_enum_list: []Enum = &mut_enum_list_buf; + _ = mut_enum_list; + // Most supported option types are serialized to a string representation, // so alternative representations of the same option value should resolve // to the same cached dependency instance. const all_specified_alt = b.dependency("other", .{ .target = @as(std.Target.Query, .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu }), - .optimize = @as([]const u8, "ReleaseSafe"), + .optimize = "ReleaseSafe", .bool = .true, - .int = @as([]const u8, "123"), + .int = "123", .float = @as(f16, 0.5), - .string = .abc, - .string_list = @as([]const []const u8, &.{ "a", "b", "c" }), + .string = mut_string, + .string_list = mut_string_list, .lazy_path = @as(std.Build.LazyPath, .{ .cwd_relative = "abc.txt" }), - .lazy_path_list = @as([]const std.Build.LazyPath, &.{ - .{ .cwd_relative = "a.txt" }, - .{ .cwd_relative = "b.txt" }, - .{ .cwd_relative = "c.txt" }, - }), - .@"enum" = @as([]const u8, "alfa"), - //.enum_list = @as([]const Enum, &.{ .alfa, .bravo, .charlie }), + .lazy_path_list = mut_lazy_path_list, + .@"enum" = "alfa", + //.enum_list = mut_enum_list, //.build_id = @as(std.zig.BuildId, .uuid), }); -- cgit v1.2.3 From 2c1a349fb9bc9965e309257262665564cff64a79 Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Mon, 24 Mar 2025 00:14:25 +0100 Subject: Support passing enum slices to `b.dependency()` --- lib/std/Build.zig | 35 ++++++++++++++++++---------- test/standalone/dependency_options/build.zig | 9 ++++--- 2 files changed, 27 insertions(+), 17 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index efff88b469..39aa0f1a4b 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -530,18 +530,29 @@ fn addUserInputOptionFromArg( }, else => {}, }, - .slice => { - comptime var slice_info = ptr_info; - slice_info.is_const = true; - slice_info.sentinel_ptr = null; - addUserInputOptionFromArg( - arena, - map, - field, - @Type(.{ .pointer = slice_info }), - maybe_value orelse null, - ); - return; + .slice => switch (@typeInfo(ptr_info.child)) { + .@"enum" => return if (maybe_value) |v| { + var list = ArrayList([]const u8).initCapacity(arena, v.len) catch @panic("OOM"); + for (v) |tag| list.appendAssumeCapacity(@tagName(tag)); + map.put(field.name, .{ + .name = field.name, + .value = .{ .list = list }, + .used = false, + }) catch @panic("OOM"); + }, + else => { + comptime var slice_info = ptr_info; + slice_info.is_const = true; + slice_info.sentinel_ptr = null; + addUserInputOptionFromArg( + arena, + map, + field, + @Type(.{ .pointer = slice_info }), + maybe_value orelse null, + ); + return; + }, }, else => {}, }, diff --git a/test/standalone/dependency_options/build.zig b/test/standalone/dependency_options/build.zig index 351a82ccdb..de7b710155 100644 --- a/test/standalone/dependency_options/build.zig +++ b/test/standalone/dependency_options/build.zig @@ -50,7 +50,7 @@ pub fn build(b: *std.Build) !void { .{ .cwd_relative = "c.txt" }, }), .@"enum" = @as(Enum, .alfa), - //.enum_list = @as([]const Enum, &.{ .alfa, .bravo, .charlie }), + .enum_list = @as([]const Enum, &.{ .alfa, .bravo, .charlie }), //.build_id = @as(std.zig.BuildId, .uuid), }); @@ -75,7 +75,7 @@ pub fn build(b: *std.Build) !void { .{ .cwd_relative = "c.txt" }, }), .@"enum" = @as(?Enum, .alfa), - //.enum_list = @as(?[]const Enum, &.{ .alfa, .bravo, .charlie }), + .enum_list = @as(?[]const Enum, &.{ .alfa, .bravo, .charlie }), //.build_id = @as(?std.zig.BuildId, .uuid), }); @@ -96,7 +96,7 @@ pub fn build(b: *std.Build) !void { .{ .cwd_relative = "c.txt" }, }, .@"enum" = .alfa, - //.enum_list = &[_]Enum{ .alfa, .bravo, .charlie }, + .enum_list = &[_]Enum{ .alfa, .bravo, .charlie }, //.build_id = @as(std.zig.BuildId, .uuid), }); @@ -114,7 +114,6 @@ pub fn build(b: *std.Build) !void { const mut_lazy_path_list: []std.Build.LazyPath = &mut_lazy_path_list_buf; var mut_enum_list_buf = [_]Enum{ .alfa, .bravo, .charlie }; const mut_enum_list: []Enum = &mut_enum_list_buf; - _ = mut_enum_list; // Most supported option types are serialized to a string representation, // so alternative representations of the same option value should resolve @@ -130,7 +129,7 @@ pub fn build(b: *std.Build) !void { .lazy_path = @as(std.Build.LazyPath, .{ .cwd_relative = "abc.txt" }), .lazy_path_list = mut_lazy_path_list, .@"enum" = "alfa", - //.enum_list = mut_enum_list, + .enum_list = mut_enum_list, //.build_id = @as(std.zig.BuildId, .uuid), }); -- cgit v1.2.3 From ca57115da7c4603dbcefce1dc9395617e28a86f8 Mon Sep 17 00:00:00 2001 From: Carl Åstholm Date: Mon, 24 Mar 2025 14:25:47 +0100 Subject: Support passing `std.zig.BuildId` to `b.dependency()` --- lib/std/Build.zig | 7 +++++++ lib/std/zig.zig | 21 +++++++++++++++++++++ test/standalone/dependency_options/build.zig | 12 ++++++++---- test/standalone/dependency_options/other/build.zig | 3 +++ 4 files changed, 39 insertions(+), 4 deletions(-) (limited to 'lib/std/Build.zig') diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 39aa0f1a4b..d6b0e68f5d 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -450,6 +450,13 @@ fn addUserInputOptionFromArg( .used = false, }) catch @panic("OOM"); }, + std.zig.BuildId => return if (maybe_value) |v| { + map.put(field.name, .{ + .name = field.name, + .value = .{ .scalar = std.fmt.allocPrint(arena, "{f}", .{v}) catch @panic("OOM") }, + .used = false, + }) catch @panic("OOM"); + }, LazyPath => return if (maybe_value) |v| { map.put(field.name, .{ .name = field.name, diff --git a/lib/std/zig.zig b/lib/std/zig.zig index 486947768d..2039a4d8c0 100644 --- a/lib/std/zig.zig +++ b/lib/std/zig.zig @@ -321,6 +321,27 @@ pub const BuildId = union(enum) { try std.testing.expectError(error.InvalidCharacter, parse("0xfoobbb")); try std.testing.expectError(error.InvalidBuildIdStyle, parse("yaddaxxx")); } + + pub fn format(id: BuildId, writer: *std.io.Writer) std.io.Writer.Error!void { + switch (id) { + .none, .fast, .uuid, .sha1, .md5 => { + try writer.writeAll(@tagName(id)); + }, + .hexstring => |hs| { + try writer.print("0x{x}", .{hs.toSlice()}); + }, + } + } + + test format { + try std.testing.expectFmt("none", "{f}", .{@as(BuildId, .none)}); + try std.testing.expectFmt("fast", "{f}", .{@as(BuildId, .fast)}); + try std.testing.expectFmt("uuid", "{f}", .{@as(BuildId, .uuid)}); + try std.testing.expectFmt("sha1", "{f}", .{@as(BuildId, .sha1)}); + try std.testing.expectFmt("md5", "{f}", .{@as(BuildId, .md5)}); + try std.testing.expectFmt("0x", "{f}", .{BuildId.initHexString("")}); + try std.testing.expectFmt("0x1234cdef", "{f}", .{BuildId.initHexString("\x12\x34\xcd\xef")}); + } }; pub const LtoMode = enum { none, full, thin }; diff --git a/test/standalone/dependency_options/build.zig b/test/standalone/dependency_options/build.zig index de7b710155..20e2db1fa2 100644 --- a/test/standalone/dependency_options/build.zig +++ b/test/standalone/dependency_options/build.zig @@ -51,7 +51,8 @@ pub fn build(b: *std.Build) !void { }), .@"enum" = @as(Enum, .alfa), .enum_list = @as([]const Enum, &.{ .alfa, .bravo, .charlie }), - //.build_id = @as(std.zig.BuildId, .uuid), + .build_id = @as(std.zig.BuildId, .uuid), + .hex_build_id = std.zig.BuildId.initHexString("\x12\x34\xcd\xef"), }); const all_specified_mod = all_specified.module("dummy"); @@ -76,7 +77,8 @@ pub fn build(b: *std.Build) !void { }), .@"enum" = @as(?Enum, .alfa), .enum_list = @as(?[]const Enum, &.{ .alfa, .bravo, .charlie }), - //.build_id = @as(?std.zig.BuildId, .uuid), + .build_id = @as(?std.zig.BuildId, .uuid), + .hex_build_id = @as(?std.zig.BuildId, .initHexString("\x12\x34\xcd\xef")), }); if (all_specified_optional != all_specified) return error.TestFailed; @@ -97,7 +99,8 @@ pub fn build(b: *std.Build) !void { }, .@"enum" = .alfa, .enum_list = &[_]Enum{ .alfa, .bravo, .charlie }, - //.build_id = @as(std.zig.BuildId, .uuid), + .build_id = .uuid, + .hex_build_id = std.zig.BuildId.initHexString("\x12\x34\xcd\xef"), }); if (all_specified_literal != all_specified) return error.TestFailed; @@ -130,7 +133,8 @@ pub fn build(b: *std.Build) !void { .lazy_path_list = mut_lazy_path_list, .@"enum" = "alfa", .enum_list = mut_enum_list, - //.build_id = @as(std.zig.BuildId, .uuid), + .build_id = "uuid", + .hex_build_id = "0x1234cdef", }); if (all_specified_alt != all_specified) return error.TestFailed; diff --git a/test/standalone/dependency_options/other/build.zig b/test/standalone/dependency_options/other/build.zig index fe676a5b25..c18f92f14d 100644 --- a/test/standalone/dependency_options/other/build.zig +++ b/test/standalone/dependency_options/other/build.zig @@ -20,6 +20,7 @@ pub fn build(b: *std.Build) !void { const expected_enum: Enum = .alfa; const expected_enum_list: []const Enum = &.{ .alfa, .bravo, .charlie }; const expected_build_id: std.zig.BuildId = .uuid; + const expected_hex_build_id: std.zig.BuildId = .initHexString("\x12\x34\xcd\xef"); const @"bool" = b.option(bool, "bool", "bool") orelse expected_bool; const int = b.option(i64, "int", "int") orelse expected_int; @@ -31,6 +32,7 @@ pub fn build(b: *std.Build) !void { const @"enum" = b.option(Enum, "enum", "enum") orelse expected_enum; const enum_list = b.option([]const Enum, "enum_list", "enum_list") orelse expected_enum_list; const build_id = b.option(std.zig.BuildId, "build_id", "build_id") orelse expected_build_id; + const hex_build_id = b.option(std.zig.BuildId, "hex_build_id", "hex_build_id") orelse expected_hex_build_id; if (@"bool" != expected_bool) return error.TestFailed; if (int != expected_int) return error.TestFailed; @@ -47,6 +49,7 @@ pub fn build(b: *std.Build) !void { if (@"enum" != expected_enum) return error.TestFailed; if (!std.mem.eql(Enum, enum_list, expected_enum_list)) return error.TestFailed; if (!std.meta.eql(build_id, expected_build_id)) return error.TestFailed; + if (!hex_build_id.eql(expected_hex_build_id)) return error.TestFailed; _ = b.addModule("dummy", .{ .root_source_file = b.path("build.zig"), -- cgit v1.2.3