remove usage of deprecated standard library APIs

Author: Techatrix

src/DiagnosticsCollection.zig

@@ -253,11 +253,11 @@ fn collectUrisFromErrorBundle(
 }
 
 fn pathToUri(allocator: std.mem.Allocator, base_path: ?[]const u8, src_path: []const u8) error{OutOfMemory}!?Uri {
-    if (std.fs.path.isAbsolute(src_path)) {
+    if (std.Io.Dir.path.isAbsolute(src_path)) {
         return try .fromPath(allocator, src_path);
     }
     const base = base_path orelse return null;
-    const absolute_src_path = try std.fs.path.join(allocator, &.{ base, src_path });
+    const absolute_src_path = try std.Io.Dir.path.join(allocator, &.{ base, src_path });
     defer allocator.free(absolute_src_path);
 
     return try .fromPath(allocator, absolute_src_path);

src/DocumentStore.zig

@@ -414,7 +414,7 @@ pub const Handle = struct {
         const tracy_zone = tracy.traceNamed(@src(), "Handle.refresh");
         defer tracy_zone.end();
 
-        const mode: Ast.Mode = if (std.mem.eql(u8, std.fs.path.extension(handle.uri.raw), ".zon")) .zon else .zig;
+        const mode: Ast.Mode = if (std.mem.eql(u8, std.Io.Dir.path.extension(handle.uri.raw), ".zon")) .zon else .zig;
         var new_tree = try parseTree(allocator, text, mode);
         errdefer new_tree.deinit(allocator);
 
@@ -847,7 +847,7 @@ pub fn openLspSyncedDocument(self: *DocumentStore, uri: Uri, text: []const u8) e
         }
     }
 
-    const duped_text = try self.allocator.dupeZ(u8, text);
+    const duped_text = try self.allocator.dupeSentinel(u8, text, 0);
     _ = self.createAndStoreDocument(
         uri,
         .{ .text = duped_text },
@@ -1013,11 +1013,11 @@ pub fn loadDirectoryRecursive(store: *DocumentStore, directory_uri: Uri) LoadDir
             }
             continue;
         }
-        if (!std.mem.eql(u8, std.fs.path.extension(entry.basename), ".zig")) continue;
+        if (!std.mem.eql(u8, std.Io.Dir.path.extension(entry.basename), ".zig")) continue;
 
         file_count += 1;
 
-        const path = try std.fs.path.join(store.allocator, &.{ workspace_path, entry.path });
+        const path = try std.Io.Dir.path.join(store.allocator, &.{ workspace_path, entry.path });
         defer store.allocator.free(path);
 
         const uri: Uri = try .fromPath(store.allocator, path);
@@ -1046,7 +1046,7 @@ pub fn loadTrigramStores(
     while (it.next()) |handle| {
         const uri = handle.uri.toStdUri();
 
-        var component_it = std.fs.path.componentIterator(uri.path.percent_encoded);
+        var component_it = std.Io.Dir.path.componentIterator(uri.path.percent_encoded);
         const skip = while (component_it.next()) |component| {
             // Keep in sync with `loadDirectoryRecursive`
             if (std.mem.startsWith(u8, component.name, ".")) break true;
@@ -1305,7 +1305,7 @@ fn loadBuildAssociatedConfiguration(io: std.Io, allocator: std.mem.Allocator, bu
 
     const build_file_path = try build_file.uri.toFsPath(allocator);
     defer allocator.free(build_file_path);
-    const config_file_path = try std.fs.path.resolve(allocator, &.{ build_file_path, "..", "zls.build.json" });
+    const config_file_path = try std.Io.Dir.path.resolve(allocator, &.{ build_file_path, "..", "zls.build.json" });
     defer allocator.free(config_file_path);
 
     const file_buf = try std.Io.Dir.cwd().readFileAlloc(
@@ -1373,7 +1373,7 @@ fn loadBuildConfiguration(self: *DocumentStore, build_file_uri: Uri, build_file_
     const build_file_path = try build_file_uri.toFsPath(self.allocator);
     defer self.allocator.free(build_file_path);
 
-    const cwd = std.fs.path.dirname(build_file_path).?;
+    const cwd = std.Io.Dir.path.dirname(build_file_path).?;
 
     const args = try self.prepareBuildRunnerArgs(build_file_uri);
     defer {
@@ -1489,16 +1489,16 @@ fn collectPotentialBuildFiles(self: *DocumentStore, uri: Uri) error{ Canceled, O
     // https://github.com/ziglang/zig/issues/15607
     const root_end_index: usize = root_end_index: {
         if (builtin.target.os.tag != .windows) break :root_end_index 0;
-        const component_iterator = std.fs.path.componentIterator(path);
+        const component_iterator = std.Io.Dir.path.componentIterator(path);
         break :root_end_index component_iterator.root_end_index;
     };
 
     var current_path: []const u8 = path;
-    while (std.fs.path.dirname(current_path)) |potential_root_path| : (current_path = potential_root_path) {
+    while (std.Io.Dir.path.dirname(current_path)) |potential_root_path| : (current_path = potential_root_path) {
         if (potential_root_path.len < root_end_index) break;
         if (!try buildDotZigExists(self.io, potential_root_path)) continue;
 
-        const build_path = try std.fs.path.join(self.allocator, &.{ potential_root_path, "build.zig" });
+        const build_path = try std.Io.Dir.path.join(self.allocator, &.{ potential_root_path, "build.zig" });
         defer self.allocator.free(build_path);
 
         try potential_build_files.ensureUnusedCapacity(self.allocator, 1);
@@ -1534,7 +1534,7 @@ fn createBuildFile(self: *DocumentStore, uri: Uri) error{ Canceled, OutOfMemory
 
         if (cfg.value.relative_builtin_path) |relative_builtin_path| blk: {
             const build_file_path = build_file.uri.toFsPath(self.allocator) catch break :blk;
-            const absolute_builtin_path = try std.fs.path.resolve(self.allocator, &.{ build_file_path, "..", relative_builtin_path });
+            const absolute_builtin_path = try std.Io.Dir.path.resolve(self.allocator, &.{ build_file_path, "..", relative_builtin_path });
             defer self.allocator.free(absolute_builtin_path);
             build_file.builtin_uri = try .fromPath(self.allocator, absolute_builtin_path);
         }
@@ -1731,15 +1731,15 @@ pub fn collectIncludeDirs(
 
             try include_dirs.ensureUnusedCapacity(allocator, module.include_dirs.len);
             for (module.include_dirs) |include_path| {
-                const absolute_path = if (std.fs.path.isAbsolute(include_path))
+                const absolute_path = if (std.Io.Dir.path.isAbsolute(include_path))
                     try allocator.dupe(u8, include_path)
                 else blk: {
                     const build_file_path = resolved.build_file.uri.toFsPath(allocator) catch |err| switch (err) {
                         error.OutOfMemory => return error.OutOfMemory,
                         error.UnsupportedScheme => continue,
                     };
-                    const build_file_dirname = std.fs.path.dirname(build_file_path) orelse continue;
-                    break :blk try std.fs.path.join(allocator, &.{ build_file_dirname, include_path });
+                    const build_file_dirname = std.Io.Dir.path.dirname(build_file_path) orelse continue;
+                    break :blk try std.Io.Dir.path.join(allocator, &.{ build_file_dirname, include_path });
                 };
 
                 include_dirs.appendAssumeCapacity(absolute_path);

src/Server.zig

@@ -739,14 +739,14 @@ fn handleConfiguration(server: *Server, json: std.json.Value) error{ Canceled, O
         const field: *?[]const u8 = &@field(new_config, file_config.name);
         if (field.*) |maybe_relative| resolve: {
             if (maybe_relative.len == 0) break :resolve;
-            if (std.fs.path.isAbsolute(maybe_relative)) break :resolve;
+            if (std.Io.Dir.path.isAbsolute(maybe_relative)) break :resolve;
 
             const root_dir = maybe_root_dir orelse {
                 log.err("relative path only supported for {s} with exactly one workspace", .{runtime_known_config_name});
                 break;
             };
 
-            const absolute = try std.fs.path.resolve(arena, &.{
+            const absolute = try std.Io.Dir.path.resolve(arena, &.{
                 root_dir, maybe_relative,
             });
 
@@ -902,7 +902,7 @@ fn didChangeWatchedFilesHandler(server: *Server, arena: std.mem.Allocator, notif
             error.OutOfMemory => return error.OutOfMemory,
             else => return error.InvalidParams,
         };
-        const file_extension = std.fs.path.extension(uri.raw);
+        const file_extension = std.Io.Dir.path.extension(uri.raw);
         if (!std.mem.eql(u8, file_extension, ".zig") and !std.mem.eql(u8, file_extension, ".zon")) continue;
 
         switch (change.type) {

src/Uri.zig

@@ -198,8 +198,8 @@ fn fromPathWithOs(
     buf.appendSliceAssumeCapacity("file:");
     if (is_windows and
         path.len >= 2 and
-        std.fs.path.PathType.isSep(.windows, u8, path[0]) and
-        std.fs.path.PathType.isSep(.windows, u8, path[1]))
+        std.Io.Dir.path.PathType.isSep(.windows, u8, path[0]) and
+        std.Io.Dir.path.PathType.isSep(.windows, u8, path[1]))
     {
         // UNC path
     } else if (!std.mem.startsWith(u8, path, "/")) {
@@ -449,7 +449,7 @@ pub fn resolveImport(
     std.Uri.Component.percentEncode(&aw.writer, sub_path, isPathChar) catch unreachable;
 
     const percent_encoded_path = parsed_uri.path.percent_encoded;
-    const joined_path = try std.fs.path.resolvePosix(allocator, &.{ percent_encoded_path, "..", aw.written() });
+    const joined_path = try std.Io.Dir.path.resolvePosix(allocator, &.{ percent_encoded_path, "..", aw.written() });
     defer allocator.free(joined_path);
 
     var buffer = aw.toArrayList();

src/analyser/InternPool.zig

@@ -426,7 +426,7 @@ pub const Key = union(enum) {
             => |a_data, t| {
                 const b_data = @field(b, @tagName(t));
 
-                const Int = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(a_data)));
+                const Int = @Int(.unsigned, @bitSizeOf(@TypeOf(a_data)));
                 return @as(Int, @bitCast(a_data)) == @as(Int, @bitCast(b_data));
             },
 

src/analyser/string_pool.zig

@@ -127,7 +127,7 @@ pub fn StringPool(comptime config: Config) type {
             defer pool.mutex.unlock(io);
             const string_bytes: [*:0]u8 = @ptrCast(pool.bytes.items.ptr);
             const start = @intFromEnum(index);
-            return try allocator.dupeZ(u8, std.mem.sliceTo(string_bytes + start, 0));
+            return try allocator.dupeSentinel(u8, std.mem.sliceTo(string_bytes + start, 0), 0);
         }
 
         /// storage a slice that points into the internal storage of the `StringPool`.

src/analysis.zig

@@ -1729,7 +1729,7 @@ fn resolveCallsiteReferences(analyser: *Analyser, decl_handle: DeclWithHandle) E
     };
 
     const tree = &decl_handle.handle.tree;
-    const is_cimport = std.mem.eql(u8, std.fs.path.basename(decl_handle.handle.uri.raw), "cimport.zig");
+    const is_cimport = std.mem.eql(u8, std.Io.Dir.path.basename(decl_handle.handle.uri.raw), "cimport.zig");
 
     if (is_cimport or !analyser.collect_callsite_references) return null;
 
@@ -4632,7 +4632,7 @@ pub const Type = struct {
                             error.OutOfMemory => return error.OutOfMemory,
                             error.UnsupportedScheme => handle.uri.raw,
                         };
-                        const str = std.fs.path.stem(path);
+                        const str = std.Io.Dir.path.stem(path);
                         try writer.writeAll(str);
                         if (referenced) |r| try r.put(analyser.arena, .of(str, handle, tree.firstToken(node)), {});
                     },
@@ -4954,7 +4954,7 @@ pub fn getFieldAccessType(
     source_index: usize,
     loc: offsets.Loc,
 ) Error!?Type {
-    const held_range = try analyser.arena.dupeZ(u8, offsets.locToSlice(handle.tree.source, loc));
+    const held_range = try analyser.arena.dupeSentinel(u8, offsets.locToSlice(handle.tree.source, loc), 0);
     var tokenizer: std.zig.Tokenizer = .init(held_range);
     var current_type: ?Type = null;
 

src/build_runner/build_runner.zig

@@ -148,7 +148,7 @@ pub fn main(init: process.Init.Minimal) !void {
             const option_contents = arg[2..];
             if (option_contents.len == 0)
                 fatalWithHint("expected option name after '-D'", .{});
-            if (mem.indexOfScalar(u8, option_contents, '=')) |name_end| {
+            if (mem.findScalar(u8, option_contents, '=')) |name_end| {
                 const option_name = option_contents[0..name_end];
                 const option_value = option_contents[name_end + 1 ..];
                 if (try builder.addUserInputOption(option_name, option_value))
@@ -369,7 +369,7 @@ pub fn main(init: process.Init.Minimal) !void {
             try buffer.appendSlice(arena, k);
             try buffer.append(arena, '\n');
         }
-        const s = std.fs.path.sep_str;
+        const s = std.Io.Dir.path.sep_str;
         const tmp_sub_path = "tmp" ++ s ++ (output_tmp_nonce orelse fatal("missing -Z arg", .{}));
         local_cache_directory.handle.writeFile(io, .{
             .sub_path = tmp_sub_path,
@@ -572,7 +572,7 @@ fn resolveStepNames(
     step_names: []const []const u8,
     check_step_only: bool,
 ) !std.AutoArrayHashMapUnmanaged(*Step, void) {
-    var starting_steps: std.AutoArrayHashMapUnmanaged(*Step, void) = .{};
+    var starting_steps: std.AutoArrayHashMapUnmanaged(*Step, void) = .empty;
     errdefer starting_steps.deinit(gpa);
 
     if (step_names.len == 0) {
@@ -1064,7 +1064,7 @@ fn extractBuildInformation(
                         if (other.generated_h) |header| {
                             try include_dirs.put(
                                 allocator,
-                                std.fs.path.dirname(header.getPath()).?,
+                                std.Io.Dir.path.dirname(header.getPath()).?,
                                 {},
                             );
                         }
@@ -1091,7 +1091,7 @@ fn extractBuildInformation(
 
             const cwd = module.owner.graph.cache.cwd;
 
-            const root_source_file_path = try std.fs.path.resolve(allocator, &.{ cwd, root_source_file.getPath2(module.owner, null) });
+            const root_source_file_path = try std.Io.Dir.path.resolve(allocator, &.{ cwd, root_source_file.getPath2(module.owner, null) });
 
             // All modules with the same root source file are merged. This limitation may be lifted in the future.
             const gop = try modules.getOrPutValue(allocator, root_source_file_path, .{
@@ -1105,7 +1105,7 @@ fn extractBuildInformation(
                 const gop_import = try gop.value_ptr.import_table.map.getOrPut(allocator, name);
                 // This does not account for the possibility of collisions (i.e. modules with same root source file import different modules under the same name).
                 if (!gop_import.found_existing) {
-                    gop_import.value_ptr.* = try std.fs.path.resolve(allocator, &.{ cwd, import_root_source_file.getPath2(import.owner, null) });
+                    gop_import.value_ptr.* = try std.Io.Dir.path.resolve(allocator, &.{ cwd, import_root_source_file.getPath2(import.owner, null) });
                 }
             }
             gop.value_ptr.c_macros = try std.mem.concat(allocator, []const u8, &.{ gop.value_ptr.c_macros, c_macros.keys() });
@@ -1221,7 +1221,7 @@ fn extractBuildInformation(
     for (all_steps.keys()) |step| {
         const compile = step.cast(Step.Compile) orelse continue;
         const root_source_file = compile.root_module.root_source_file orelse continue;
-        const root_source_file_path = try std.fs.path.resolve(arena, &.{ b.graph.cache.cwd, root_source_file.getPath2(compile.root_module.owner, null) });
+        const root_source_file_path = try std.Io.Dir.path.resolve(arena, &.{ b.graph.cache.cwd, root_source_file.getPath2(compile.root_module.owner, null) });
         try compilations.append(arena, .{
             .root_module = root_source_file_path,
         });
@@ -1252,7 +1252,7 @@ fn extractBuildInformation(
                 try root_dependencies.put(
                     arena,
                     root_dep[0],
-                    try std.fs.path.join(arena, &.{ package_info.build_root, "build.zig" }),
+                    try std.Io.Dir.path.join(arena, &.{ package_info.build_root, "build.zig" }),
                 );
             }
         }
@@ -1353,7 +1353,7 @@ const copied_from_zig = struct {
 
             // Now try appending ".0".
             for (pkgs) |pkg| {
-                if (std.ascii.indexOfIgnoreCase(pkg.name, lib_name)) |pos| {
+                if (std.ascii.findIgnoreCase(pkg.name, lib_name)) |pos| {
                     if (pos != 0) continue;
                     if (mem.eql(u8, pkg.name[lib_name.len..], ".0")) {
                         break :match pkg.name;

src/build_runner/shared.zig

@@ -131,7 +131,12 @@ pub const BuildOnSaveSupport = union(enum) {
 
 /// Parses a Linux Kernel Version. The result will ignore pre-release and build metadata.
 fn parseUnameKernelVersion(kernel_version: []const u8) !std.SemanticVersion {
-    const extra_index = std.mem.indexOfAny(u8, kernel_version, "-+");
+    const extra_index = for (kernel_version, 0..) |c, i| {
+        switch (c) {
+            '-', '+' => break i,
+            else => continue,
+        }
+    } else null;
     const required = kernel_version[0..(extra_index orelse kernel_version.len)];
     var it = std.mem.splitScalar(u8, required, '.');
     return .{