From b92b55ab8e11614a587929bc66c023b9fe7cf7f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Sun, 23 Mar 2025 18:48:05 +0100 Subject: [PATCH 001/110] Update test build.zig.zon files to conform to the new manifest rules --- test/link/build.zig.zon | 3 ++- test/standalone/build.zig.zon | 2 +- test/standalone/dependencyFromBuildZig/build.zig.zon | 3 ++- test/standalone/dependencyFromBuildZig/other/build.zig.zon | 3 ++- 4 files changed, 7 insertions(+), 4 deletions(-) diff --git a/test/link/build.zig.zon b/test/link/build.zig.zon index 16bba08c4e018dcd8c13aef2a2db6599411fdadc..ab44726091eddf978caeb4553f3ee69ceb22abfc 100644 --- a/test/link/build.zig.zon +++ b/test/link/build.zig.zon @@ -1,5 +1,6 @@ .{ - .name = "link_test_cases", + .name = .link_test_cases, + .fingerprint = 0x404f657576fec9f2, .version = "0.0.0", .dependencies = .{ .bss = .{ diff --git a/test/standalone/build.zig.zon b/test/standalone/build.zig.zon index 8cf899477f30bd0cbeb556a15b3f2cc1c67c2e95..afbe3fcfa8601f82e312c97a605a22faf8c53888 100644 --- a/test/standalone/build.zig.zon +++ b/test/standalone/build.zig.zon @@ -1,6 +1,6 @@ .{ .name = .standalone_test_cases, - .fingerprint = 0xc0dbdf9c818957be, + .fingerprint = 0xc0dbdf9c3b92810b, .version = "0.0.0", .dependencies = .{ .simple = .{ diff --git a/test/standalone/dependencyFromBuildZig/build.zig.zon b/test/standalone/dependencyFromBuildZig/build.zig.zon index 085ae2c80b45d4393640895dda8a8f9e4c39db35..fda6a098d8da887a5fb94f56b67672a4149bc20e 100644 --- a/test/standalone/dependencyFromBuildZig/build.zig.zon +++ b/test/standalone/dependencyFromBuildZig/build.zig.zon @@ -1,5 +1,6 @@ .{ - .name = "dependencyFromBuildZig", + .name = .dependencyFromBuildZig, + .fingerprint = 0xfd939a1eb8169080, .version = "0.0.0", .dependencies = .{ .other = .{ diff --git a/test/standalone/dependencyFromBuildZig/other/build.zig.zon b/test/standalone/dependencyFromBuildZig/other/build.zig.zon index 204abdbbba3d5361a66a24ebc5c2454f437f9a7a..bb8fcb6fb4c433715b6b10360de445f6fe531477 100644 --- a/test/standalone/dependencyFromBuildZig/other/build.zig.zon +++ b/test/standalone/dependencyFromBuildZig/other/build.zig.zon @@ -1,5 +1,6 @@ .{ - .name = "other", + .name = .other, + .fingerprint = 0xd9583520a2405f6c, .version = "0.0.0", .dependencies = .{}, .paths = .{""}, -- 2.54.0 From 00bc72b5ff01c7f8ceb4b58e82614e22a147ccc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Sun, 23 Mar 2025 20:38:41 +0100 Subject: [PATCH 002/110] Add standalone test case for passing options to dependencies --- test/standalone/build.zig.zon | 3 + test/standalone/dependency_options/build.zig | 63 +++++++++++++++++++ .../dependency_options/build.zig.zon | 11 ++++ .../dependency_options/other/build.zig | 56 +++++++++++++++++ .../dependency_options/other/build.zig.zon | 7 +++ 5 files changed, 140 insertions(+) create mode 100644 test/standalone/dependency_options/build.zig create mode 100644 test/standalone/dependency_options/build.zig.zon create mode 100644 test/standalone/dependency_options/other/build.zig create mode 100644 test/standalone/dependency_options/other/build.zig.zon diff --git a/test/standalone/build.zig.zon b/test/standalone/build.zig.zon index afbe3fcfa8601f82e312c97a605a22faf8c53888..bdd059ab378d61669701ef930dc68e9715216053 100644 --- a/test/standalone/build.zig.zon +++ b/test/standalone/build.zig.zon @@ -181,6 +181,9 @@ .install_headers = .{ .path = "install_headers", }, + .dependency_options = .{ + .path = "dependency_options", + }, .dependencyFromBuildZig = .{ .path = "dependencyFromBuildZig", }, diff --git a/test/standalone/dependency_options/build.zig b/test/standalone/dependency_options/build.zig new file mode 100644 index 0000000000000000000000000000000000000000..8726f61d30fbf3f91b2b1053d7fc15039d34014d --- /dev/null +++ b/test/standalone/dependency_options/build.zig @@ -0,0 +1,63 @@ +const std = @import("std"); + +pub const Enum = enum { alfa, bravo, charlie }; + +pub fn build(b: *std.Build) !void { + const test_step = b.step("test", "Test passing options to a dependency"); + b.default_step = test_step; + + const none_specified = b.dependency("other", .{}); + + const none_specified_mod = none_specified.module("dummy"); + if (!none_specified_mod.resolved_target.?.query.eql(b.graph.host.query)) return error.TestFailed; + if (none_specified_mod.optimize.? != .Debug) return error.TestFailed; + + const all_specified = b.dependency("other", .{ + .target = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu }), + .optimize = @as(std.builtin.OptimizeMode, .ReleaseSafe), + .bool = @as(bool, true), + .int = @as(i64, 123), + .float = @as(f64, 0.5), + .string = @as([]const u8, "abc"), + .string_list = @as([]const []const u8, &.{ "a", "b", "c" }), + .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(Enum, .alfa), + //.enum_list = @as([]const Enum, &.{ .alfa, .bravo, .charlie }), + //.build_id = @as(std.zig.BuildId, .uuid), + }); + + const all_specified_mod = all_specified.module("dummy"); + if (all_specified_mod.resolved_target.?.result.cpu.arch != .x86_64) return error.TestFailed; + if (all_specified_mod.resolved_target.?.result.os.tag != .windows) return error.TestFailed; + if (all_specified_mod.resolved_target.?.result.abi != .gnu) return error.TestFailed; + if (all_specified_mod.optimize.? != .ReleaseSafe) return error.TestFailed; + + // 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"), + .bool = .true, + .int = @as([]const u8, "123"), + .float = @as(f16, 0.5), + .string = .abc, + .string_list = @as([]const []const u8, &.{ "a", "b", "c" }), + .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 }), + //.build_id = @as(std.zig.BuildId, .uuid), + }); + + if (all_specified != all_specified_alt) return error.TestFailed; +} diff --git a/test/standalone/dependency_options/build.zig.zon b/test/standalone/dependency_options/build.zig.zon new file mode 100644 index 0000000000000000000000000000000000000000..6788640a806501d253897380b88bb3c05cc482a6 --- /dev/null +++ b/test/standalone/dependency_options/build.zig.zon @@ -0,0 +1,11 @@ +.{ + .name = .dependency_options, + .fingerprint = 0x3e3ce1c1f92ba47e, + .version = "0.0.0", + .dependencies = .{ + .other = .{ + .path = "other", + }, + }, + .paths = .{""}, +} diff --git a/test/standalone/dependency_options/other/build.zig b/test/standalone/dependency_options/other/build.zig new file mode 100644 index 0000000000000000000000000000000000000000..fe676a5b25a8a977bd68f5de0d0a6e60ea5d944f --- /dev/null +++ b/test/standalone/dependency_options/other/build.zig @@ -0,0 +1,56 @@ +const std = @import("std"); + +pub const Enum = enum { alfa, bravo, charlie }; + +pub fn build(b: *std.Build) !void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const expected_bool: bool = true; + const expected_int: i64 = 123; + const expected_float: f64 = 0.5; + const expected_string: []const u8 = "abc"; + const expected_string_list: []const []const u8 = &.{ "a", "b", "c" }; + const expected_lazy_path: std.Build.LazyPath = .{ .cwd_relative = "abc.txt" }; + const expected_lazy_path_list: []const std.Build.LazyPath = &.{ + .{ .cwd_relative = "a.txt" }, + .{ .cwd_relative = "b.txt" }, + .{ .cwd_relative = "c.txt" }, + }; + const expected_enum: Enum = .alfa; + const expected_enum_list: []const Enum = &.{ .alfa, .bravo, .charlie }; + const expected_build_id: std.zig.BuildId = .uuid; + + const @"bool" = b.option(bool, "bool", "bool") orelse expected_bool; + const int = b.option(i64, "int", "int") orelse expected_int; + const float = b.option(f64, "float", "float") orelse expected_float; + const string = b.option([]const u8, "string", "string") orelse expected_string; + const string_list = b.option([]const []const u8, "string_list", "string_list") orelse expected_string_list; + const lazy_path = b.option(std.Build.LazyPath, "lazy_path", "lazy_path") orelse expected_lazy_path; + const lazy_path_list = b.option([]const std.Build.LazyPath, "lazy_path_list", "lazy_path_list") orelse expected_lazy_path_list; + 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; + + if (@"bool" != expected_bool) return error.TestFailed; + if (int != expected_int) return error.TestFailed; + if (float != expected_float) return error.TestFailed; + if (!std.mem.eql(u8, string, expected_string)) return error.TestFailed; + if (string_list.len != expected_string_list.len) return error.TestFailed; + for (string_list, expected_string_list) |x, y| { + if (!std.mem.eql(u8, x, y)) return error.TestFailed; + } + if (!std.mem.eql(u8, lazy_path.cwd_relative, expected_lazy_path.cwd_relative)) return error.TestFailed; + for (lazy_path_list, expected_lazy_path_list) |x, y| { + if (!std.mem.eql(u8, x.cwd_relative, y.cwd_relative)) return error.TestFailed; + } + 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; + + _ = b.addModule("dummy", .{ + .root_source_file = b.path("build.zig"), + .target = target, + .optimize = optimize, + }); +} diff --git a/test/standalone/dependency_options/other/build.zig.zon b/test/standalone/dependency_options/other/build.zig.zon new file mode 100644 index 0000000000000000000000000000000000000000..d49a2cdcf86ac353887826f53ea0d530bf28ae80 --- /dev/null +++ b/test/standalone/dependency_options/other/build.zig.zon @@ -0,0 +1,7 @@ +.{ + .name = .other, + .fingerprint = 0xd95835207bc8b630, + .version = "0.0.0", + .dependencies = .{}, + .paths = .{""}, +} -- 2.54.0 From 5380e81924dd98e9717eaf09ae05e935952a78ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Sun, 23 Mar 2025 22:45:38 +0100 Subject: [PATCH 003/110] Support passing null to `b.dependency()` Both null literals and optionals are supported. --- lib/std/Build.zig | 179 +++++++++++-------- test/standalone/dependency_options/build.zig | 46 ++++- 2 files changed, 146 insertions(+), 79 deletions(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index e65a71e12bc139da413d1988bf7ec6c7894367ef..e5b9e072f7cdbe52006e5c11a1f3b49943662771 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"); + .null => unreachable, + .optional => |info| switch (@typeInfo(info.child)) { + .optional => {}, + else => { + addUserInputOptionFromArg( + arena, + map, + field, + info.child, + maybe_value orelse null, + ); + return; }, - .@"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"); - }, - .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) { diff --git a/test/standalone/dependency_options/build.zig b/test/standalone/dependency_options/build.zig index 8726f61d30fbf3f91b2b1053d7fc15039d34014d..27ce63834d81deb365efaf8e3727ea8b669ec505 100644 --- a/test/standalone/dependency_options/build.zig +++ b/test/standalone/dependency_options/build.zig @@ -12,6 +12,29 @@ pub fn build(b: *std.Build) !void { if (!none_specified_mod.resolved_target.?.query.eql(b.graph.host.query)) return error.TestFailed; if (none_specified_mod.optimize.? != .Debug) return error.TestFailed; + // Passing null is the same as not specifying the option, + // so this should resolve to the same cached dependency instance. + const null_specified = b.dependency("other", .{ + // Null literals + .target = null, + .optimize = null, + .bool = null, + + // Optionals + .int = @as(?i64, null), + .float = @as(?f64, null), + + // Optionals of the wrong type + .string = @as(?usize, null), + .@"enum" = @as(?bool, null), + + // Non-defined option names + .this_option_does_not_exist = null, + .neither_does_this_one = @as(?[]const u8, null), + }); + + if (null_specified != none_specified) return error.TestFailed; + const all_specified = b.dependency("other", .{ .target = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu }), .optimize = @as(std.builtin.OptimizeMode, .ReleaseSafe), @@ -37,6 +60,27 @@ pub fn build(b: *std.Build) !void { if (all_specified_mod.resolved_target.?.result.abi != .gnu) return error.TestFailed; if (all_specified_mod.optimize.? != .ReleaseSafe) return error.TestFailed; + const all_specified_optional = b.dependency("other", .{ + .target = @as(?std.Build.ResolvedTarget, b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu })), + .optimize = @as(?std.builtin.OptimizeMode, .ReleaseSafe), + .bool = @as(?bool, true), + .int = @as(?i64, 123), + .float = @as(?f64, 0.5), + .string = @as(?[]const u8, "abc"), + .string_list = @as(?[]const []const u8, &.{ "a", "b", "c" }), + .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(?Enum, .alfa), + //.enum_list = @as(?[]const Enum, &.{ .alfa, .bravo, .charlie }), + //.build_id = @as(?std.zig.BuildId, .uuid), + }); + + if (all_specified_optional != all_specified) return error.TestFailed; + // 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. @@ -59,5 +103,5 @@ pub fn build(b: *std.Build) !void { //.build_id = @as(std.zig.BuildId, .uuid), }); - if (all_specified != all_specified_alt) return error.TestFailed; + if (all_specified_alt != all_specified) return error.TestFailed; } -- 2.54.0 From e7604bba3ef0654a882edb17d712d1beb2cefec9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Mon, 24 Mar 2025 13:22:08 +0100 Subject: [PATCH 004/110] 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(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index e5b9e072f7cdbe52006e5c11a1f3b49943662771..1c73767009e7ee3f1b5b80dd2c03be0522a90cad 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 09a1c8f81b4d477fb8a589fe7592bec1588ed310..1a717f0bca0e519a5439506abd4a466e709d824c 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)); -- 2.54.0 From 1a9fae2a70371fdbd77446fd5173162bfa065624 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Mon, 24 Mar 2025 13:25:56 +0100 Subject: [PATCH 005/110] Dupe string options --- lib/std/Build.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 1c73767009e7ee3f1b5b80dd2c03be0522a90cad..21eb5196edbbc70b37805179d0245914c6a2fd16 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 }, -- 2.54.0 From fd5eba9358ebf2f498b7c35bae34267f06d070d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Mon, 24 Mar 2025 00:01:28 +0100 Subject: [PATCH 006/110] 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(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 21eb5196edbbc70b37805179d0245914c6a2fd16..efff88b469f3af274526884fec4a8f6b66518800 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 27ce63834d81deb365efaf8e3727ea8b669ec505..351a82ccdbcac193eb8ae6058198fa0fdb616753 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), }); -- 2.54.0 From 2c1a349fb9bc9965e309257262665564cff64a79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Mon, 24 Mar 2025 00:14:25 +0100 Subject: [PATCH 007/110] 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(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index efff88b469f3af274526884fec4a8f6b66518800..39aa0f1a4b5ee765e9a1ecc0acee853389749052 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 351a82ccdbcac193eb8ae6058198fa0fdb616753..de7b7101554e4055d0f0c1be61443ec0eb60ef82 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), }); -- 2.54.0 From ca57115da7c4603dbcefce1dc9395617e28a86f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carl=20=C3=85stholm?= Date: Mon, 24 Mar 2025 14:25:47 +0100 Subject: [PATCH 008/110] 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 +++++++---- .../dependency_options/other/build.zig | 3 +++ 4 files changed, 39 insertions(+), 4 deletions(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 39aa0f1a4b5ee765e9a1ecc0acee853389749052..d6b0e68f5d4abcf42d548a6bd40678c57b2b3942 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 486947768d7933e5633c06485ad4f7c15b78b376..2039a4d8c0efff853d0c8695e4e930ddd71d5a2a 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 de7b7101554e4055d0f0c1be61443ec0eb60ef82..20e2db1fa24f551db53a30e4ad51305f73ca6a50 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 fe676a5b25a8a977bd68f5de0d0a6e60ea5d944f..c18f92f14d6c3adfffc2daa800b3a93b40866fbf 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"), -- 2.54.0 From 3c046ab9d94c96632bdfd21ad20bea0613bfc1e2 Mon Sep 17 00:00:00 2001 From: IOKG04 Date: Tue, 22 Jul 2025 12:23:16 +0200 Subject: [PATCH 009/110] `[:x]T` coerces into `[*:x]T` https://github.com/ziglang/zig/issues/9628 --- doc/langref/test_coerce_slices_arrays_and_pointers.zig | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/doc/langref/test_coerce_slices_arrays_and_pointers.zig b/doc/langref/test_coerce_slices_arrays_and_pointers.zig index b2fdb6c787f844bd145484f0d18be7d5536d1c41..67b2687163f58bf78c07e0873d2d41e56d1e1502 100644 --- a/doc/langref/test_coerce_slices_arrays_and_pointers.zig +++ b/doc/langref/test_coerce_slices_arrays_and_pointers.zig @@ -67,4 +67,11 @@ test "*T to *[1]T" { try expect(z[0] == 1234); } +// Sentinel-terminated slices can be coerced into sentinel-terminated pointers +test "[:x]T to [*:x]T" { + const buf: [:0]const u8 = "hello"; + const buf2: [*:0]const u8 = buf; + try expect(buf2[4] == 'o'); +} + // test -- 2.54.0 From a91b4aab734ec17273ca8ea5e4a8afabd6193107 Mon Sep 17 00:00:00 2001 From: IOKG04 Date: Tue, 22 Jul 2025 12:32:45 +0200 Subject: [PATCH 010/110] error return traces are *not* enabled for ReleaseSafe https://github.com/ziglang/zig/issues/24232 --- doc/langref.html.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/langref.html.in b/doc/langref.html.in index e8189e5c420ce42559b313b9b16090a5c8b94455..348f35444d84f57b25830cafadaefc03cf21cf1b 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -3215,7 +3215,7 @@ fn createFoo(param: i32) !Foo { to increase their development pace.

- Error Return Traces are enabled by default in {#link|Debug#} and {#link|ReleaseSafe#} builds and disabled by default in {#link|ReleaseFast#} and {#link|ReleaseSmall#} builds. + Error Return Traces are enabled by default in {#link|Debug#} builds and disabled by default in {#link|ReleaseFast#}, {#link|ReleaseSafe#} and {#link|ReleaseSmall#} builds.

There are a few ways to activate this error return tracing feature: -- 2.54.0 From 84ae54fbe64a15301317716e7f901d81585332d5 Mon Sep 17 00:00:00 2001 From: IOKG04 Date: Tue, 22 Jul 2025 13:15:43 +0200 Subject: [PATCH 011/110] `@rem()` and `@mod()` take `denominator != 0`, not just `denominator > 0` https://github.com/ziglang/zig/issues/23635 I also added tests for `@rem()` with `denominator < 0` cause there were none before I hope I added them in the correct place, if not I can change it ofc --- doc/langref.html.in | 4 ++-- test/behavior/math.zig | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/langref.html.in b/doc/langref.html.in index 348f35444d84f57b25830cafadaefc03cf21cf1b..139c19211e7200afad48443f8b5e1e24fa479542 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -5179,7 +5179,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val 

{#syntax#}@mod(numerator: T, denominator: T) T{#endsyntax#}

Modulus division. For unsigned integers this is the same as - {#syntax#}numerator % denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator > 0{#endsyntax#}, otherwise the + {#syntax#}numerator % denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator != 0{#endsyntax#}, otherwise the operation will result in a {#link|Remainder Division by Zero#} when runtime safety checks are enabled.