Revert tool/build changes per review

philocalyst · philocalyst · commit e9519cbe32ee · 2026-07-09T04:50:10.000-04:00
diff --git a/sim/aviron/build.zig b/sim/aviron/build.zig
@@ -73,7 +73,7 @@ pub fn build(b: *Build) !void {
 
     const run_cmd = b.addRunArtifact(aviron_exe);
     run_cmd.step.dependOn(b.getInstallStep());
-
+    run_cmd.addPassthruArgs();
     run_step.dependOn(&run_cmd.step);
 
     const avr_target = b.resolveTargetQuery(avr_target_query);
@@ -156,7 +156,7 @@ fn add_test_suite(
     // Scan the testsuite directory for files. Based on the extension, either load or compile them.
     // Files in testsuite.avr-gcc will be compiled with avr-gcc and have the output copied to
     // this directory.
-    var walkdir = try b.build_root.handle.openDir(io, "testsuite", .{ .iterate = true });
+    var walkdir = try b.root.root_dir.handle.openDir(io, "testsuite", .{ .iterate = true });
     defer walkdir.close(io);
 
     var walker = try walkdir.walk(b.allocator);
@@ -192,8 +192,7 @@ fn add_test_suite(
         };
 
         const ext = std.fs.path.extension(entry.basename);
-        const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".fields) |field| {
-            const field_name = field.name;
+        const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".field_names) |field_name| {
             const action: FileAction = @field(extension_to_action, field_name);
 
             if (std.mem.eql(u8, ext, "." ++ field_name))
@@ -332,10 +331,12 @@ fn add_test_suite_update(
     b: *Build,
     invoke_step: *Build.Step,
 ) !void {
-    const avr_gcc: Build.LazyPath = .{ .cwd_relative = try b.findProgram(&.{"avr-gcc"}, &.{}) };
+    const avr_gcc = b.findProgramLazy(.{
+        .names = &.{"avr-gcc"},
+    });
 
     const io = b.graph.io;
-    var walkdir = try b.build_root.handle.openDir(io, "testsuite.avr-gcc", .{ .iterate = true });
+    var walkdir = try b.root.root_dir.handle.openDir(io, "testsuite.avr-gcc", .{ .iterate = true });
     defer walkdir.close(io);
 
     var walker = try walkdir.walk(b.allocator);
@@ -363,8 +364,7 @@ fn add_test_suite_update(
         };
 
         const ext = std.fs.path.extension(entry.basename);
-        const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".fields) |field| {
-            const field_name = field.name;
+        const action: FileAction = inline for (@typeInfo(@TypeOf(extension_to_action)).@"struct".field_names) |field_name| {
             const action: FileAction = @field(extension_to_action, field_name);
             if (std.mem.eql(u8, ext, "." ++ field_name))
                 break action;
diff --git a/tools/linter/build.zig b/tools/linter/build.zig
@@ -18,7 +18,7 @@ pub fn build(b: *std.Build) void {
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);
-
+    run_cmd.addPassthruArgs();
     run_cmd.step.dependOn(b.getInstallStep());
 
     const run_step = b.step("run", "Run the app");
diff --git a/tools/regz/build.zig b/tools/regz/build.zig
@@ -67,7 +67,7 @@ pub fn build(b: *Build) !void {
     b.installArtifact(regz);
 
     const run_cmd = b.addRunArtifact(regz);
-
+    run_cmd.addPassthruArgs();
     run_cmd.step.dependOn(b.getInstallStep());
 
     const run_step = b.step("run", "Run the app");
diff --git a/tools/regz/src/Database.zig b/tools/regz/src/Database.zig
@@ -364,9 +364,9 @@ pub const Access = enum {
     pub const default = .read_write;
 
     pub fn to_string(access: Access) []const u8 {
-        return inline for (@typeInfo(Access).@"enum".fields) |field| {
-            if (@field(Access, field.name) == access)
-                break field.name;
+        return inline for (@typeInfo(Access).@"enum".field_names) |field_name| {
+            if (@field(Access, field_name) == access)
+                break field_name;
         } else unreachable;
     }
 };
@@ -383,14 +383,14 @@ fn gen_field_list(comptime T: type, opts: struct { prefix: ?[]const u8 = null })
     var buf: [4096]u8 = undefined;
     var fbs: std.Io.Writer = .fixed(&buf);
 
-    inline for (@typeInfo(T).@"struct".fields, 0..) |field, i| {
+    inline for (@typeInfo(T).@"struct".field_names, 0..) |field_name, i| {
         if (i != 0)
             fbs.writeAll(", ") catch unreachable;
 
         if (opts.prefix) |prefix|
             fbs.print("{s}.", .{prefix}) catch unreachable;
 
-        fbs.print("{s}", .{field.name}) catch unreachable;
+        fbs.print("{s}", .{field_name}) catch unreachable;
     }
 
     const buf_copy = buf;
@@ -423,9 +423,9 @@ fn gen_sql_table_impl(comptime name: []const u8, comptime T: type) ![:0]const u8
     var primary_key_found = T.sql_opts.primary_key == null;
 
     const info = @typeInfo(T);
-    inline for (info.@"struct".fields) |field| {
+    inline for (info.@"struct".field_names) |field_name| {
         if (T.sql_opts.primary_key) |primary_key| {
-            if (std.mem.eql(u8, primary_key.name, field.name))
+            if (std.mem.eql(u8, primary_key.name, field_name))
                 primary_key_found = true;
         }
     }
@@ -434,21 +434,21 @@ fn gen_sql_table_impl(comptime name: []const u8, comptime T: type) ![:0]const u8
 
     try fbs.print("CREATE TABLE {s} (\n", .{name});
     var first = true;
-    inline for (info.@"struct".fields) |field| {
+    inline for (info.@"struct".field_names, info.@"struct".field_types) |field_name, field_type| {
         if (first) {
             first = false;
         } else {
             try fbs.writeAll(",\n");
         }
-        try fbs.print("  {s}", .{field.name});
-        try fbs.print(" {s}", .{zig_type_to_sql_type(field.type)});
+        try fbs.print("  {s}", .{field_name});
+        try fbs.print(" {s}", .{zig_type_to_sql_type(field_type)});
 
-        const field_type_info = @typeInfo(field.type);
+        const field_type_info = @typeInfo(field_type);
         if (field_type_info != .optional)
             try fbs.writeAll(" NOT NULL");
 
         if (T.sql_opts.primary_key) |primary_key| {
-            if (std.mem.eql(u8, primary_key.name, field.name)) {
+            if (std.mem.eql(u8, primary_key.name, field_name)) {
                 try fbs.writeAll(" PRIMARY KEY");
 
                 if (primary_key.autoincrement)
@@ -474,9 +474,9 @@ fn gen_sql_table_impl(comptime name: []const u8, comptime T: type) ![:0]const u8
     for (T.sql_opts.foreign_keys) |foreign_key| {
         try fbs.writeAll(",\n");
 
-        const field_type = for (@typeInfo(T).@"struct".fields) |field| {
-            if (std.mem.eql(u8, field.name, foreign_key.name))
-                break field.type;
+        const field_type = for (@typeInfo(T).@"struct".field_names, @typeInfo(T).@"struct".field_types) |field_name, field_type| {
+            if (std.mem.eql(u8, field_name, foreign_key.name))
+                break field_type;
         } else unreachable;
 
         try fbs.print("  FOREIGN KEY ({s}) REFERENCES {s}(id) ON DELETE {s} ON UPDATE {s}\n", .{
@@ -776,31 +776,31 @@ pub fn get_device_id_by_name(db: *Database, name: []const u8) !?DeviceID {
 fn scan_row(comptime T: type, allocator: Allocator, row: zqlite.Row) !T {
     var entry: T = undefined;
     const info = @typeInfo(T).@"struct";
-    inline for (info.fields, 0..) |field, i| {
-        if (@typeInfo(field.type) == .@"enum") {
-            if (@hasDecl(field.type, "to_string"))
-                @field(entry, field.name) = std.meta.stringToEnum(field.type, row.text(i)) orelse return error.Unknown
+    inline for (info.field_names, info.field_types, 0..) |field_name, field_type, i| {
+        if (@typeInfo(field_type) == .@"enum") {
+            if (@hasDecl(field_type, "to_string"))
+                @field(entry, field_name) = std.meta.stringToEnum(field_type, row.text(i)) orelse return error.Unknown
             else
-                @field(entry, field.name) = @enumFromInt(row.int(i));
-        } else if (@typeInfo(field.type) == .int) {
-            @field(entry, field.name) = @intCast(row.int(i));
-        } else switch (field.type) {
+                @field(entry, field_name) = @enumFromInt(row.int(i));
+        } else if (@typeInfo(field_type) == .int) {
+            @field(entry, field_name) = @intCast(row.int(i));
+        } else switch (field_type) {
             []const u8 => {
-                @field(entry, field.name) = try allocator.dupe(u8, row.text(i));
+                @field(entry, field_name) = try allocator.dupe(u8, row.text(i));
             },
             ?[]const u8 => {
-                @field(entry, field.name) = if (row.nullableText(i)) |text| try allocator.dupe(u8, text) else null;
+                @field(entry, field_name) = if (row.nullableText(i)) |text| try allocator.dupe(u8, text) else null;
             },
             ?u64, ?u16, ?u8 => {
-                @field(entry, field.name) = if (row.nullableInt(i)) |value| @intCast(value) else null;
+                @field(entry, field_name) = if (row.nullableInt(i)) |value| @intCast(value) else null;
             },
             ?StructID, ?EnumID => {
-                @field(entry, field.name) = if (row.nullableInt(i)) |value| @enumFromInt(value) else null;
+                @field(entry, field_name) = if (row.nullableInt(i)) |value| @enumFromInt(value) else null;
             },
             ?Access => {
-                @field(entry, field.name) = if (row.nullableText(i)) |text| (std.meta.stringToEnum(Access, text) orelse return error.Unknown) else null;
+                @field(entry, field_name) = if (row.nullableText(i)) |text| (std.meta.stringToEnum(Access, text) orelse return error.Unknown) else null;
             },
-            else => @compileError(std.fmt.comptimePrint("unhandled column type: {s}", .{@typeName(field.type)})),
+            else => @compileError(std.fmt.comptimePrint("unhandled column type: {s}", .{@typeName(field_type)})),
         }
     }
 
diff --git a/tools/regz/src/VirtualFilesystem.zig b/tools/regz/src/VirtualFilesystem.zig
@@ -108,6 +108,7 @@ fn operate(userdata: ?*anyopaque, op: std.Io.Operation) std.Io.Cancelable!std.Io
         .file_read_streaming => unreachable,
         .device_io_control => unreachable,
         .net_receive => unreachable,
+        .net_read => unreachable,
     };
 }
 
@@ -378,7 +379,6 @@ pub fn io(vfs: *VirtualFilesystem) std.Io {
             .netConnectUnix = std.Io.failingNetConnectUnix,
             .netSocketCreatePair = std.Io.failingNetSocketCreatePair,
             .netSend = std.Io.failingNetSend,
-            .netRead = std.Io.failingNetRead,
 
             .netWrite = std.Io.failingNetWrite,
             .netWriteFile = std.Io.failingNetWriteFile,
diff --git a/tools/regz/src/arch.zig b/tools/regz/src/arch.zig
@@ -52,9 +52,9 @@ pub const Arch = enum {
     pub const default = .unknown;
 
     pub fn to_string(arch: Arch) []const u8 {
-        return inline for (@typeInfo(Arch).@"enum".fields) |field| {
-            if (@field(Arch, field.name) == arch)
-                break field.name;
+        return inline for (@typeInfo(Arch).@"enum".field_names) |field_name| {
+            if (@field(Arch, field_name) == arch)
+                break field_name;
         } else unreachable;
     }
 
diff --git a/tools/regz/src/arch/arm.zig b/tools/regz/src/arch/arm.zig
@@ -53,8 +53,7 @@ const system_interrupts = struct {
 pub fn load_system_interrupts(db: *Database, device_id: DeviceID, arch: Arch) !void {
     assert(arch.is_arm());
 
-    inline for (@typeInfo(Arch).@"enum".fields) |field| {
-        const field_name = field.name;
+    inline for (@typeInfo(Arch).@"enum".field_names) |field_name| {
         if (arch == @field(Arch, field_name)) {
             if (@hasDecl(system_interrupts, field_name)) {
                 for (@field(system_interrupts, field_name)) |interrupt| {
diff --git a/tools/regz/src/svd.zig b/tools/regz/src/svd.zig
@@ -33,9 +33,9 @@ const Context = struct {
     ) !RegisterProperties {
         const register_props = try RegisterProperties.parse(node);
         var base_register_props = ctx.register_props.get(from) orelse unreachable;
-        inline for (@typeInfo(RegisterProperties).@"struct".fields) |field| {
-            if (@field(register_props, field.name)) |value|
-                @field(base_register_props, field.name) = value;
+        inline for (@typeInfo(RegisterProperties).@"struct".field_names) |field_name| {
+            if (@field(register_props, field_name)) |value|
+                @field(base_register_props, field_name) = value;
         }
 
         return base_register_props;
diff --git a/tools/regz/src/targetdb.zig b/tools/regz/src/targetdb.zig
@@ -24,9 +24,9 @@ fn parse_isa_to_arch(isa: []const u8) Arch {
     const lower = std.ascii.lowerString(&buf, isa);
 
     // Try to match against all Arch enum values
-    inline for (@typeInfo(Arch).@"enum".fields) |field| {
-        if (std.mem.eql(u8, lower, field.name)) {
-            return @field(Arch, field.name);
+    inline for (@typeInfo(Arch).@"enum".field_names) |field_name| {
+        if (std.mem.eql(u8, lower, field_name)) {
+            return @field(Arch, field_name);
         }
     }
 
diff --git a/tools/sorcerer/build.zig b/tools/sorcerer/build.zig
@@ -63,7 +63,7 @@ pub fn build(b: *std.Build) void {
     b.installArtifact(cli_exe);
 
     const run_cli_cmd = b.addRunArtifact(cli_exe);
-
+    run_cli_cmd.addPassthruArgs();
     run_cli_cmd.step.dependOn(b.getInstallStep());
 
     const run_cli_step = b.step("run-cli", "Run the CLI tool");
@@ -152,6 +152,7 @@ pub fn build(b: *std.Build) void {
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);
+    run_cmd.addPassthruArgs();
 
     // I only want the path to the register schema file, not the lazy path,
     // because I want to be able to refresh it with `zig build` while sorcerer

Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,9 @@ fn parse_isa_to_arch(isa: []const u8) Arch {`
`24`	`24`	`const lower = std.ascii.lowerString(&buf, isa);`
`25`	`25`
`26`	`26`	`// Try to match against all Arch enum values`
`27`		`- inline for (@typeInfo(Arch).@"enum".fields) \|field\| {`
`28`		`- if (std.mem.eql(u8, lower, field.name)) {`
`29`		`- return @field(Arch, field.name);`
	`27`	`+ inline for (@typeInfo(Arch).@"enum".field_names) \|field_name\| {`
	`28`	`+ if (std.mem.eql(u8, lower, field_name)) {`
	`29`	`+ return @field(Arch, field_name);`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`