update to zig 0.11.0

lun-4 · lun-4 · commit 9e682e8ebf44 · 2023-09-18T13:24:23.000-03:00
diff --git a/build.zig b/build.zig
@@ -16,8 +16,8 @@ const EXECUTABLES = .{
 
 fn addGraphicsMagick(thing: anytype) void {
     thing.linkLibC();
-    thing.addIncludePath("/usr/include");
-    thing.addIncludePath("/usr/include/GraphicsMagick");
+    thing.addIncludePath(.{ .path = "/usr/include" });
+    thing.addIncludePath(.{ .path = "/usr/include/GraphicsMagick" });
 }
 
 pub fn build(b: *std.build.Builder) !void {
@@ -57,20 +57,22 @@ pub fn build(b: *std.build.Builder) !void {
 
         deps.addAllTo(single_exe);
         addGraphicsMagick(single_exe);
+        b.installArtifact(single_exe);
 
         const hardlink_install = try b.allocator.create(CustomHardLinkStep);
+
+        var hardlink_step = std.build.Step.init(.{
+            .id = .custom,
+            .name = "link the utils",
+            .owner = b,
+            .makeFn = CustomHardLinkStep.make,
+        });
         hardlink_install.* = .{
             .builder = b,
-            .step = std.build.Step.init(.{
-                .id = .custom,
-                .name = "link the utils",
-                .owner = b,
-                .makeFn = CustomHardLinkStep.make,
-            }),
+            .step = hardlink_step,
             .exe = single_exe,
         };
         hardlink_install.step.dependOn(&single_exe.step);
-
         b.getInstallStep().dependOn(&hardlink_install.step);
     } else {
         // release modes build all exes separately
@@ -87,7 +89,7 @@ pub fn build(b: *std.build.Builder) !void {
                 },
             );
 
-            tool_exe.install();
+            b.installArtifact(tool_exe);
             addGraphicsMagick(tool_exe);
             deps.addAllTo(tool_exe);
         }
@@ -106,18 +108,18 @@ const CustomHardLinkStep = struct {
         const self: *Self = @fieldParentPtr(Self, "step", step);
         const builder = self.builder;
 
+        const wrapmain_path = self.exe.getEmittedBin().getPath(builder);
         inline for (EXECUTABLES) |exec_decl| {
             const exec_name = exec_decl.@"0";
             const full_dest_path = builder.getInstallPath(.{ .bin = {} }, exec_name);
+            std.debug.print("{s} -> {s}\n", .{ wrapmain_path, full_dest_path });
             _ = try std.fs.Dir.updateFile(
                 std.fs.cwd(),
-                self.exe.output_path_source.path.?,
+                wrapmain_path,
                 std.fs.cwd(),
                 full_dest_path,
                 .{},
             );
-
-            //try builder.updateFile(self.exe.output_path_source.path.?, full_dest_path);
         }
     }
 };
diff --git a/src/find_main.zig b/src/find_main.zig
@@ -221,10 +221,10 @@ pub fn main() anyerror!void {
         std.mem.copy(u8, &tmp_path, PREFIX);
         var fill_here = tmp_path[PREFIX.len..];
 
-        const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
+        const seed = @as(u64, @truncate(@as(u128, @bitCast(std.time.nanoTimestamp()))));
         var r = std.rand.DefaultPrng.init(seed);
         for (fill_here) |*el| {
-            const ascii_idx = @intCast(u8, r.random().uintLessThan(u5, 24));
+            const ascii_idx = @as(u8, @intCast(r.random().uintLessThan(u5, 24)));
             const letter: u8 = @as(u8, 65) + ascii_idx;
             el.* = letter;
         }
@@ -445,7 +445,7 @@ pub const SqlGiver = struct {
             for (self.operators, 0..) |regex, current_regex_index| {
                 logger.debug("try regex {d} on query '{s}'", .{ current_regex_index, query_slice });
                 maybe_captures = try regex.captures(allocator, query_slice, .{});
-                maybe_captured_regex_index = @intToEnum(CaptureType, current_regex_index);
+                maybe_captured_regex_index = @as(CaptureType, @enumFromInt(current_regex_index));
                 logger.debug("raw capture? {any}", .{maybe_captures});
                 if (maybe_captures) |captures| {
                     const capture = captures[0].?;
diff --git a/src/hydrus_api_main.zig b/src/hydrus_api_main.zig
@@ -164,7 +164,7 @@ fn mainHandler(
     logger.info("{s} {s} {d}", .{
         methodString(request),
         request.path(),
-        @enumToInt(response.status_code),
+        @intFromEnum(response.status_code),
     });
 }
 
diff --git a/src/id_migration.zig b/src/id_migration.zig
@@ -48,7 +48,7 @@ fn migrateFiles(self: *Context) !void {
     defer stmt.deinit();
 
     var rng = std.rand.DefaultPrng.init(
-        @truncate(u64, @intCast(u128, std.time.nanoTimestamp())),
+        @as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())))),
     );
     const random = rng.random();
 
@@ -113,7 +113,7 @@ fn migrateFiles(self: *Context) !void {
 
 fn migrateCores(self: *Context) !void {
     var rng = std.rand.DefaultPrng.init(
-        @truncate(u64, @intCast(u128, std.time.nanoTimestamp())),
+        @as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())))),
     );
     const random = rng.random();
 
@@ -262,7 +262,7 @@ fn migrateTagFiles(self: *Context) !void {
 }
 
 fn migratePools(self: *Context) !void {
-    var rng = std.rand.DefaultPrng.init(@truncate(u64, @intCast(u128, std.time.nanoTimestamp())));
+    var rng = std.rand.DefaultPrng.init(@as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())))));
     const random = rng.random();
 
     var stmt = try self.db.prepare(
diff --git a/src/include_main.zig b/src/include_main.zig
@@ -251,7 +251,7 @@ fn getGraphicsMagickApi() ?GraphicsMagickApi {
 
     var api: GraphicsMagickApi = undefined;
     inline for (@typeInfo(GraphicsMagickApi).Struct.fields) |field_decl| {
-        const name_cstr = std.cstr.addNullByte(alloc, field_decl.name) catch unreachable;
+        const name_cstr = alloc.dupeZ(u8, field_decl.name) catch unreachable;
         defer fba.reset();
 
         @field(api, field_decl.name) = gm_clib.lookup(field_decl.type, name_cstr).?;
@@ -338,7 +338,7 @@ const RegexTagInferrer = struct {
 
     pub fn init(config: TagInferrerConfig, allocator: std.mem.Allocator) !RunContext {
         const regex_config = config.config.regex;
-        const regex_cstr = try std.cstr.addNullByte(allocator, regex_config.text.?);
+        const regex_cstr = try allocator.dupeZ(u8, regex_config.text.?);
         var gm_api = if (regex_config.use_exif) getGraphicsMagickApi().? else null;
         return RunContext{
             .allocator = allocator,
@@ -373,7 +373,7 @@ const RegexTagInferrer = struct {
             var buf: [std.os.PATH_MAX]u8 = undefined;
             var fba = std.heap.FixedBufferAllocator{ .end_index = 0, .buffer = &buf };
             var alloc = fba.allocator();
-            const path_cstr = std.cstr.addNullByte(alloc, file.local_path) catch unreachable;
+            const path_cstr = alloc.dupeZ(u8, file.local_path) catch unreachable;
 
             gm_api.InitializeMagick(null);
             std.mem.copy(u8, &info.*.filename, path_cstr);
@@ -764,8 +764,8 @@ const MimeTagInferrer = struct {
         //
         // Only adding log statements made me even realize the error location
         if (config.config.mime.tag_for_all_video) |tag_for_all_video| {
-            std.debug.assert(@ptrToInt(tag_for_all_video.ptr) ==
-                @ptrToInt(self.config.tag_for_all_video.?.ptr));
+            std.debug.assert(@intFromPtr(tag_for_all_video.ptr) ==
+                @intFromPtr(self.config.tag_for_all_video.?.ptr));
         }
 
         return self;
@@ -780,7 +780,7 @@ const MimeTagInferrer = struct {
         file: *const Context.File,
         tags_to_add: *std.ArrayList([]const u8),
     ) !void {
-        const path_cstr = try std.cstr.addNullByte(self.allocator, file.local_path);
+        const path_cstr = try self.allocator.dupeZ(u8, file.local_path);
         defer self.allocator.free(path_cstr);
 
         var mimetype = try self.cookie.inferFile(path_cstr);
@@ -1138,7 +1138,7 @@ pub fn main() anyerror!void {
 
             while (try walker.next()) |entry| {
                 switch (entry.kind) {
-                    .File, .SymLink => {
+                    .file, .sym_link => {
                         logger.debug(
                             "adding child path '{s}{s}{s}'",
                             .{ path_to_include, std.fs.path.sep_str, entry.path },
diff --git a/src/ls_main.zig b/src/ls_main.zig
@@ -152,12 +152,12 @@ pub fn main() anyerror!void {
             while (try it.next()) |entry| {
                 // TODO get stat?
                 switch (entry.kind) {
-                    .File => try stdout.print("-", .{}),
-                    .Directory => try stdout.print("d", .{}),
+                    .file => try stdout.print("-", .{}),
+                    .directory => try stdout.print("d", .{}),
                     else => try stdout.print("-", .{}),
                 }
                 try stdout.print(" {s}", .{entry.name});
-                if (entry.kind == .File) {
+                if (entry.kind == .file) {
                     var realpath_buf: [std.os.PATH_MAX]u8 = undefined;
                     const full_path = try dir.dir.realpath(entry.name, &realpath_buf);
                     var maybe_inner_file = try ctx.fetchFileByPath(full_path);
diff --git a/src/main.zig b/src/main.zig
@@ -345,7 +345,7 @@ pub const ID = struct {
 
     pub fn generate() Self {
         var rng = std.rand.DefaultPrng.init(
-            @truncate(u64, @intCast(u128, std.time.nanoTimestamp())),
+            @as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())))),
         );
         const rand = rng.random();
         const generated_ulid = ulidFromTimestamp(rand, std.time.milliTimestamp());
@@ -354,7 +354,7 @@ pub const ID = struct {
 
     pub fn generateWithTimestamp(milliTimestamp: anytype) Self {
         var rng = std.rand.DefaultPrng.init(
-            @truncate(u64, @intCast(u128, std.time.nanoTimestamp())),
+            @as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())))),
         );
         const rand = rng.random();
 
@@ -442,7 +442,7 @@ pub fn loadDatabase(allocator: std.mem.Allocator, given_options: LoadDatabaseOpt
         options.home_path = home_path;
     }
 
-    const db_path_cstr = try std.cstr.addNullByte(allocator, options.db_path.?);
+    const db_path_cstr = try allocator.dupeZ(u8, options.db_path.?);
     defer allocator.free(db_path_cstr);
 
     var diags: sqlite.Diagnostics = undefined;
@@ -846,7 +846,7 @@ pub const Context = struct {
     /// Caller owns the returned memory.
     fn randomCoreData(self: *Self, core_output: []u8) void {
         _ = self;
-        const seed = @truncate(u64, @bitCast(u128, std.time.nanoTimestamp()));
+        const seed = @as(u64, @truncate(@as(u128, @bitCast(std.time.nanoTimestamp()))));
         var r = std.rand.DefaultPrng.init(seed);
         for (core_output, 0..) |_, index| {
             var random_byte = r.random().uintAtMost(u8, 255);
@@ -925,10 +925,7 @@ pub const Context = struct {
 
             if (tag_name_regex) |tag_name_regex_string| {
                 defer self.allocator.free(tag_name_regex_string);
-                self.library_config.tag_name_regex_string = try std.cstr.addNullByte(
-                    self.allocator,
-                    tag_name_regex_string,
-                );
+                self.library_config.tag_name_regex_string = try self.allocator.dupeZ(u8, tag_name_regex_string);
 
                 self.library_config.tag_name_regex = try libpcre.Regex.compile(
                     self.library_config.tag_name_regex_string.?,
@@ -941,7 +938,7 @@ pub const Context = struct {
     pub fn updateLibraryConfig(self: *Self, field: LibraryConfiguration.FieldUpdateRequest) !void {
         switch (field) {
             .tag_name_regex => |new_regex| {
-                const new_regex_cstr = try std.cstr.addNullByte(self.allocator, new_regex);
+                const new_regex_cstr = try self.allocator.dupeZ(u8, new_regex);
                 defer self.allocator.free(new_regex_cstr);
                 const regex = libpcre.Regex.compile(new_regex_cstr, DefaultRegexOptions) catch |err| {
                     logger.err("failed to compile regex: {s}", .{@errorName(err)});
@@ -1072,7 +1069,7 @@ pub const Context = struct {
             if (options.source) |source| {
                 if (options.parent_source_id) |parent_source_id| {
                     if (source.kind != TagSourceType.system) return error.InvalidSourceType;
-                    if (source.id != @enumToInt(SystemTagSources.tag_parenting)) {
+                    if (source.id != @intFromEnum(SystemTagSources.tag_parenting)) {
                         logger.err("expected tag parent source, got {}", .{source});
                         return error.InvalidSourceID;
                     }
@@ -1082,15 +1079,15 @@ pub const Context = struct {
                         \\values (?, ?, ?, ?, ?) on conflict do nothing
                     ,
                         .{},
-                        .{ core_hash.id.sql(), self.hash.id.sql(), @enumToInt(source.kind), source.id, parent_source_id },
+                        .{ core_hash.id.sql(), self.hash.id.sql(), @intFromEnum(source.kind), source.id, parent_source_id },
                     );
                 } else {
                     try self.ctx.db.exec(
                         \\insert into tag_files (core_hash, file_hash, tag_source_type, tag_source_id)
                         \\values (?, ?, ?, ?) on conflict do nothing
                     ,
                         .{},
-                        .{ core_hash.id.sql(), self.hash.id.sql(), @enumToInt(source.kind), source.id },
+                        .{ core_hash.id.sql(), self.hash.id.sql(), @intFromEnum(source.kind), source.id },
                     );
                 }
             } else {
@@ -1159,7 +1156,7 @@ pub const Context = struct {
                 try self.ctx.db.exec(
                     "delete from tag_sources where type = ? and id = ?",
                     .{},
-                    .{ @enumToInt(TagSourceType.external), self.id },
+                    .{ @intFromEnum(TagSourceType.external), self.id },
                 );
             }
         };
@@ -1208,7 +1205,7 @@ pub const Context = struct {
                     .core = hash_with_blob.toRealHash(),
                     .source = Source{
                         .ctx = self.ctx,
-                        .kind = @intToEnum(TagSourceType, row.tag_source_type),
+                        .kind = @as(TagSourceType, @enumFromInt(row.tag_source_type)),
                         .id = row.tag_source_id,
                     },
                     .parent_source_id = row.parent_source_id,
@@ -1273,7 +1270,7 @@ pub const Context = struct {
         try self.db.exec(
             "insert into tag_sources (type, id, name) values (?, ?, ?)",
             .{},
-            .{ @enumToInt(TagSourceType.external), source_id, name },
+            .{ @intFromEnum(TagSourceType.external), source_id, name },
         );
 
         return File.Source{ .ctx = self, .kind = .external, .id = source_id };
@@ -1292,7 +1289,7 @@ pub const Context = struct {
                     struct { type: i64, id: i64 },
                     "select type, id from tag_sources where type = ? and id = ?",
                     .{},
-                    .{ @enumToInt(TagSourceType.external), id },
+                    .{ @intFromEnum(TagSourceType.external), id },
                 );
 
                 if (maybe_row) |row| {
@@ -1657,7 +1654,7 @@ pub const Context = struct {
             });
 
             try file.addTag(.{ .id = tag_entry.tag_id, .hash_data = undefined }, .{
-                .source = try self.fetchTagSource(.system, @enumToInt(SystemTagSources.tag_parenting)),
+                .source = try self.fetchTagSource(.system, @intFromEnum(SystemTagSources.tag_parenting)),
                 .parent_source_id = tag_entry.parent_entry_id,
             });
         }
@@ -1977,7 +1974,7 @@ pub fn log(
     comptime format: []const u8,
     args: anytype,
 ) void {
-    if (@enumToInt(message_level) <= @enumToInt(@import("root").current_log_level)) {
+    if (@intFromEnum(message_level) <= @intFromEnum(@import("root").current_log_level)) {
         std.log.defaultLog(message_level, scope, format, args);
     }
 }
@@ -2371,7 +2368,7 @@ test "tag parenting" {
     for (file_tags) |file_tag| {
         if (std.meta.eql(file_tag.core.id, parent_tag.core.id)) {
             try std.testing.expectEqual(TagSourceType.system, file_tag.source.kind);
-            try std.testing.expectEqual(@as(i64, @enumToInt(SystemTagSources.tag_parenting)), file_tag.source.id);
+            try std.testing.expectEqual(@as(i64, @intFromEnum(SystemTagSources.tag_parenting)), file_tag.source.id);
             try std.testing.expectEqual(tag_tree_entry_id, file_tag.parent_source_id.?);
             saw_parent = true;
         }
diff --git a/src/rename_watcher_main.zig b/src/rename_watcher_main.zig
@@ -605,7 +605,7 @@ pub fn main() anyerror!void {
 
     const pidfd_rc = std.os.linux.pidfd_open(proc.id, 0);
     switch (std.os.errno(pidfd_rc)) {
-        .SUCCESS => pidfd = @intCast(std.os.fd_t, pidfd_rc),
+        .SUCCESS => pidfd = @as(std.os.fd_t, @intCast(pidfd_rc)),
         .INVAL => unreachable,
         .NFILE, .MFILE => return error.TooManyFileDescriptors,
         .NODEV => return error.NoDevice,
diff --git a/src/rm_main.zig b/src/rm_main.zig
@@ -196,7 +196,7 @@ pub fn main() anyerror!void {
             defer walker.deinit();
 
             while (try walker.next()) |entry| {
-                if (entry.kind != .File) continue;
+                if (entry.kind != .file) continue;
                 logger.debug("checking path {s}", .{entry.path});
                 var inner_realpath_buffer: [std.os.PATH_MAX]u8 = undefined;
                 const inner_full_path = try entry.dir.realpath(entry.basename, &inner_realpath_buffer);
diff --git a/src/snowflake.zig b/src/snowflake.zig
diff --git a/src/tags_main.zig b/src/tags_main.zig
diff --git a/src/test_migrations.zig b/src/test_migrations.zig
diff --git a/zigmod.lock b/zigmod.lock

Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ fn mainHandler(`
`164`	`164`	`logger.info("{s} {s} {d}", .{`
`165`	`165`	`methodString(request),`
`166`	`166`	`request.path(),`
`167`		`- @enumToInt(response.status_code),`
	`167`	`+ @intFromEnum(response.status_code),`
`168`	`168`	`});`
`169`	`169`	`}`
`170`	`170`