authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-01-28 19:40:43-08:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-01-29 18:40:55-08:00
log649aaf4814f8b74d9f90c0aaa09cbaf1901a6650
tree4fccf7c255e4423b03db0541956e4978856282b1
parent9b415761dd66904aef363e387b4501f3ddd0bf76

std: migrate getcwd to Io

progress towards #30150

24 files changed, 122 insertions(+), 154 deletions(-)

lib/compiler/build_runner.zig+1-1
......@@ -83,7 +83,7 @@ pub fn main(init: process.Init.Minimal) !void {
8383 .io = io,
8484 .gpa = gpa,
8585 .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
86 .cwd = try process.getCwdAlloc(single_threaded_arena.allocator()),
86 .cwd = try process.currentDirAlloc(io, single_threaded_arena.allocator()),
8787 },
8888 .zig_exe = zig_exe,
8989 .environ_map = try init.environ.createMap(arena),
lib/std/Build/Cache.zig+4-4
......@@ -1315,7 +1315,7 @@ test "cache file and then recall it" {
13151315 var tmp = testing.tmpDir(.{});
13161316 defer tmp.cleanup();
13171317
1318 const cwd = try std.process.getCwdAlloc(testing.allocator);
1318 const cwd = try std.process.currentDirAlloc(io, testing.allocator);
13191319 defer testing.allocator.free(cwd);
13201320
13211321 const temp_file = "test.txt";
......@@ -1383,7 +1383,7 @@ test "check that changing a file makes cache fail" {
13831383 var tmp = testing.tmpDir(.{});
13841384 defer tmp.cleanup();
13851385
1386 const cwd = try std.process.getCwdAlloc(testing.allocator);
1386 const cwd = try std.process.currentDirAlloc(io, testing.allocator);
13871387 defer testing.allocator.free(cwd);
13881388
13891389 const temp_file = "cache_hash_change_file_test.txt";
......@@ -1459,7 +1459,7 @@ test "no file inputs" {
14591459 var tmp = testing.tmpDir(.{});
14601460 defer tmp.cleanup();
14611461
1462 const cwd = try std.process.getCwdAlloc(testing.allocator);
1462 const cwd = try std.process.currentDirAlloc(io, testing.allocator);
14631463 defer testing.allocator.free(cwd);
14641464
14651465 const temp_manifest_dir = "no_file_inputs_manifest_dir";
......@@ -1509,7 +1509,7 @@ test "Manifest with files added after initial hash work" {
15091509 var tmp = testing.tmpDir(.{});
15101510 defer tmp.cleanup();
15111511
1512 const cwd = try std.process.getCwdAlloc(testing.allocator);
1512 const cwd = try std.process.currentDirAlloc(io, testing.allocator);
15131513 defer testing.allocator.free(cwd);
15141514
15151515 const temp_file1 = "cache_hash_post_file_test1.txt";
lib/std/Build/Step/Options.zig+1-1
......@@ -519,7 +519,7 @@ test Options {
519519 var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
520520 defer arena.deinit();
521521
522 const cwd = try std.process.getCwdAlloc(std.testing.allocator);
522 const cwd = try std.process.currentDirAlloc(io, std.testing.allocator);
523523 defer std.testing.allocator.free(cwd);
524524
525525 var graph: std.Build.Graph = .{
lib/std/Io.zig+1
......@@ -665,6 +665,7 @@ pub const VTable = struct {
665665 lockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!LockedStderr,
666666 tryLockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!?LockedStderr,
667667 unlockStderr: *const fn (?*anyopaque) void,
668 processCurrentDir: *const fn (?*anyopaque, buffer: []u8) std.process.CurrentDirError!usize,
668669 processSetCurrentDir: *const fn (?*anyopaque, Dir) std.process.SetCurrentDirError!void,
669670 processReplace: *const fn (?*anyopaque, std.process.ReplaceOptions) std.process.ReplaceError,
670671 processReplacePath: *const fn (?*anyopaque, Dir, std.process.ReplaceOptions) std.process.ReplaceError,
lib/std/Io/Threaded.zig+42
......@@ -1643,6 +1643,7 @@ pub fn io(t: *Threaded) Io {
16431643 .lockStderr = lockStderr,
16441644 .tryLockStderr = tryLockStderr,
16451645 .unlockStderr = unlockStderr,
1646 .processCurrentDir = processCurrentDir,
16461647 .processSetCurrentDir = processSetCurrentDir,
16471648 .processReplace = processReplace,
16481649 .processReplacePath = processReplacePath,
......@@ -1801,6 +1802,7 @@ pub fn ioBasic(t: *Threaded) Io {
18011802 .lockStderr = lockStderr,
18021803 .tryLockStderr = tryLockStderr,
18031804 .unlockStderr = unlockStderr,
1805 .processCurrentDir = processCurrentDir,
18041806 .processSetCurrentDir = processSetCurrentDir,
18051807 .processReplace = processReplace,
18061808 .processReplacePath = processReplacePath,
......@@ -12600,6 +12602,46 @@ fn unlockStderr(userdata: ?*anyopaque) void {
1260012602 process.stderr_thread_mutex.unlock();
1260112603}
1260212604
12605fn processCurrentDir(userdata: ?*anyopaque, buffer: []u8) process.CurrentDirError!usize {
12606 const t: *Threaded = @ptrCast(@alignCast(userdata));
12607 _ = t;
12608 if (is_windows) {
12609 var wtf16le_buf: [windows.PATH_MAX_WIDE:0]u16 = undefined;
12610 const n = windows.ntdll.RtlGetCurrentDirectory_U(wtf16le_buf.len + 1, &wtf16le_buf);
12611 if (n == 0) return error.Unexpected;
12612 assert(n <= wtf16le_buf.len);
12613 const wtf16le_slice = wtf16le_buf[0..n];
12614 var end_index: usize = 0;
12615 var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
12616 while (it.nextCodepoint()) |codepoint| {
12617 const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
12618 if (end_index + seq_len >= buffer.len)
12619 return error.NameTooLong;
12620 end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
12621 }
12622 return end_index;
12623 } else if (native_os == .wasi and !builtin.link_libc) {
12624 if (buffer.len == 0) return error.NameTooLong;
12625 buffer[0] = '.';
12626 return 1;
12627 }
12628
12629 const err: posix.E = if (builtin.link_libc) err: {
12630 const c_err = if (std.c.getcwd(buffer.ptr, buffer.len)) |_| 0 else std.c._errno().*;
12631 break :err @enumFromInt(c_err);
12632 } else err: {
12633 break :err posix.errno(posix.system.getcwd(buffer.ptr, buffer.len));
12634 };
12635 switch (err) {
12636 .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
12637 .NOENT => return error.CurrentWorkingDirectoryUnlinked,
12638 .RANGE => return error.NameTooLong,
12639 .FAULT => |e| return errnoBug(e),
12640 .INVAL => |e| return errnoBug(e),
12641 else => return posix.unexpectedErrno(err),
12642 }
12643}
12644
1260312645fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
1260412646 if (native_os == .wasi) return error.OperationUnsupported;
1260512647 const t: *Threaded = @ptrCast(@alignCast(userdata));
lib/std/fs/test.zig+1-1
......@@ -1787,7 +1787,7 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
17871787
17881788 const gpa = testing.allocator;
17891789
1790 const cwd = try std.process.getCwdAlloc(gpa);
1790 const cwd = try std.process.currentDirAlloc(io, gpa);
17911791 defer gpa.free(cwd);
17921792
17931793 const filename = try Dir.path.resolve(gpa, &.{ cwd, sub_path });
lib/std/os/windows.zig-28
......@@ -2878,34 +2878,6 @@ pub fn CloseHandle(hObject: HANDLE) void {
28782878 assert(ntdll.NtClose(hObject) == .SUCCESS);
28792879}
28802880
2881pub const GetCurrentDirectoryError = error{
2882 NameTooLong,
2883 Unexpected,
2884};
2885
2886/// The result is a slice of `buffer`, indexed from 0.
2887/// The result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
2888pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
2889 var wtf16le_buf: [PATH_MAX_WIDE:0]u16 = undefined;
2890 const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len + 1, &wtf16le_buf);
2891 if (result == 0) {
2892 switch (GetLastError()) {
2893 else => |err| return unexpectedError(err),
2894 }
2895 }
2896 assert(result <= wtf16le_buf.len);
2897 const wtf16le_slice = wtf16le_buf[0..result];
2898 var end_index: usize = 0;
2899 var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
2900 while (it.nextCodepoint()) |codepoint| {
2901 const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
2902 if (end_index + seq_len >= buffer.len)
2903 return error.NameTooLong;
2904 end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
2905 }
2906 return buffer[0..end_index];
2907}
2908
29092881pub const GetStdHandleError = error{
29102882 NoStandardHandleAttached,
29112883 Unexpected,
lib/std/os/windows/kernel32.zig-6
......@@ -128,12 +128,6 @@ pub extern "kernel32" fn SetFileCompletionNotificationModes(
128128 Flags: UCHAR,
129129) callconv(.winapi) BOOL;
130130
131// TODO: `RtlGetCurrentDirectory_U(nBufferLength * 2, lpBuffer)`
132pub extern "kernel32" fn GetCurrentDirectoryW(
133 nBufferLength: DWORD,
134 lpBuffer: ?[*]WCHAR,
135) callconv(.winapi) DWORD;
136
137131pub extern "kernel32" fn ReadFile(
138132 hFile: HANDLE,
139133 lpBuffer: LPVOID,
lib/std/os/windows/ntdll.zig+5
......@@ -496,6 +496,11 @@ pub extern "ntdll" fn RtlGetFullPathName_U(
496496 ShortName: ?*[*:0]const u16,
497497) callconv(.winapi) ULONG;
498498
499pub extern "ntdll" fn RtlGetCurrentDirectory_U(
500 BufferLength: ULONG,
501 Buffer: [*]u16,
502) callconv(.winapi) ULONG;
503
499504pub extern "ntdll" fn RtlGetSystemTimePrecise() callconv(.winapi) LARGE_INTEGER;
500505
501506pub extern "ntdll" fn RtlInitializeCriticalSection(
lib/std/posix.zig-34
......@@ -519,40 +519,6 @@ pub fn getppid() pid_t {
519519 return system.getppid();
520520}
521521
522pub const GetCwdError = error{
523 NameTooLong,
524 /// Not possible on Windows.
525 CurrentWorkingDirectoryUnlinked,
526} || UnexpectedError;
527
528/// The result is a slice of out_buffer, indexed from 0.
529pub fn getcwd(out_buffer: []u8) GetCwdError![]u8 {
530 if (native_os == .windows) {
531 return windows.GetCurrentDirectory(out_buffer);
532 } else if (native_os == .wasi and !builtin.link_libc) {
533 const path = ".";
534 if (out_buffer.len < path.len) return error.NameTooLong;
535 const result = out_buffer[0..path.len];
536 @memcpy(result, path);
537 return result;
538 }
539
540 const err: E = if (builtin.link_libc) err: {
541 const c_err = if (std.c.getcwd(out_buffer.ptr, out_buffer.len)) |_| 0 else std.c._errno().*;
542 break :err @enumFromInt(c_err);
543 } else err: {
544 break :err errno(system.getcwd(out_buffer.ptr, out_buffer.len));
545 };
546 switch (err) {
547 .SUCCESS => return mem.sliceTo(out_buffer, 0),
548 .FAULT => unreachable,
549 .INVAL => unreachable,
550 .NOENT => return error.CurrentWorkingDirectoryUnlinked,
551 .RANGE => return error.NameTooLong,
552 else => return unexpectedErrno(err),
553 }
554}
555
556522pub const SocketError = error{
557523 /// Permission to create a socket of the specified type and/or
558524 /// pro‐tocol is denied.
lib/std/process.zig+26-39
......@@ -63,53 +63,40 @@ pub const Init = struct {
6363 };
6464};
6565
66pub const GetCwdError = posix.GetCwdError;
66pub const CurrentDirError = error{
67 NameTooLong,
68 /// Not possible on Windows. Always returned on WASI.
69 CurrentWorkingDirectoryUnlinked,
70} || Io.UnexpectedError;
6771
68/// The result is a slice of `out_buffer`, from index `0`.
6972/// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
70/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
71pub fn getCwd(out_buffer: []u8) GetCwdError![]u8 {
72 return posix.getcwd(out_buffer);
73/// On other platforms, the result is an opaque sequence of bytes with no
74/// particular encoding.
75pub fn currentDir(io: Io, buffer: []u8) CurrentDirError!usize {
76 return io.vtable.processCurrentDir(io.userdata, buffer);
7377}
7478
75// Same as GetCwdError, minus error.NameTooLong + Allocator.Error
76pub const GetCwdAllocError = Allocator.Error || error{
77 /// Not possible on Windows.
79pub const CurrentDirAllocError = Allocator.Error || error{
80 /// Not possible on Windows. Always returned on WASI.
7881 CurrentWorkingDirectoryUnlinked,
79} || posix.UnexpectedError;
82} || Io.UnexpectedError;
8083
81/// Caller must free the returned memory.
8284/// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
83/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
84pub fn getCwdAlloc(allocator: Allocator) GetCwdAllocError![]u8 {
85 // The use of max_path_bytes here is just a heuristic: most paths will fit
86 // in stack_buf, avoiding an extra allocation in the common case.
87 var stack_buf: [max_path_bytes]u8 = undefined;
88 var heap_buf: ?[]u8 = null;
89 defer if (heap_buf) |buf| allocator.free(buf);
90
91 var current_buf: []u8 = &stack_buf;
92 while (true) {
93 if (posix.getcwd(current_buf)) |slice| {
94 return allocator.dupe(u8, slice);
95 } else |err| switch (err) {
96 error.NameTooLong => {
97 // The path is too long to fit in stack_buf. Allocate geometrically
98 // increasing buffers until we find one that works
99 const new_capacity = current_buf.len * 2;
100 if (heap_buf) |buf| allocator.free(buf);
101 current_buf = try allocator.alloc(u8, new_capacity);
102 heap_buf = current_buf;
103 },
104 else => |e| return e,
105 }
106 }
85/// On other platforms, the result is an opaque sequence of bytes with no
86/// particular encoding.
87///
88/// Caller owns returned memory.
89pub fn currentDirAlloc(io: Io, allocator: Allocator) CurrentDirAllocError![:0]u8 {
90 var buffer: [max_path_bytes]u8 = undefined;
91 const n = currentDir(io, &buffer) catch |err| switch (err) {
92 error.NameTooLong => unreachable,
93 else => |e| return e,
94 };
95 return allocator.dupeZ(u8, buffer[0..n]);
10796}
10897
109test getCwdAlloc {
110 if (native_os == .wasi) return error.SkipZigTest;
111
112 const cwd = try getCwdAlloc(testing.allocator);
98test currentDirAlloc {
99 const cwd = try currentDirAlloc(testing.io, testing.allocator);
113100 testing.allocator.free(cwd);
114101}
115102
......@@ -466,7 +453,7 @@ pub fn spawnPath(io: Io, dir: Io.Dir, options: SpawnOptions) SpawnError!Child {
466453 return io.vtable.processSpawnPath(io.userdata, dir, options);
467454}
468455
469pub const RunError = posix.GetCwdError || posix.ReadError || SpawnError || posix.PollError || error{
456pub const RunError = CurrentDirError || posix.ReadError || SpawnError || posix.PollError || error{
470457 StdoutStreamTooLong,
471458 StderrStreamTooLong,
472459};
src/Compilation.zig+1-1
......@@ -767,7 +767,7 @@ pub const Directories = struct {
767767 ) Directories {
768768 const wasi = builtin.target.os.tag == .wasi;
769769
770 const cwd = introspect.getResolvedCwd(arena) catch |err| {
770 const cwd = introspect.getResolvedCwd(io, arena) catch |err| {
771771 fatal("unable to get cwd: {t}", .{err});
772772 };
773773
src/introspect.zig+5-5
......@@ -43,7 +43,7 @@ fn testZigInstallPrefix(io: Io, base_dir: Io.Dir) ?Cache.Directory {
4343
4444/// Both the directory handle and the path are newly allocated resources which the caller now owns.
4545pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
46 const cwd_path = try getResolvedCwd(gpa);
46 const cwd_path = try getResolvedCwd(io, gpa);
4747 defer gpa.free(cwd_path);
4848 const self_exe_path = try std.process.executablePathAlloc(io, gpa);
4949 defer gpa.free(self_exe_path);
......@@ -51,23 +51,23 @@ pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
5151 return findZigLibDirFromSelfExe(gpa, io, cwd_path, self_exe_path);
5252}
5353
54/// Like `std.process.getCwdAlloc`, but also resolves the path with `Dir.path.resolve`. This
54/// Like `std.process.currentDirAlloc`, but also resolves the path with `Dir.path.resolve`. This
5555/// means the path has no repeated separators, no "." or ".." components, and no trailing separator.
5656/// On WASI, "" is returned instead of ".".
57pub fn getResolvedCwd(gpa: Allocator) error{
57pub fn getResolvedCwd(io: Io, gpa: Allocator) error{
5858 OutOfMemory,
5959 CurrentWorkingDirectoryUnlinked,
6060 Unexpected,
6161}![]u8 {
6262 if (builtin.target.os.tag == .wasi) {
6363 if (std.debug.runtime_safety) {
64 const cwd = try std.process.getCwdAlloc(gpa);
64 const cwd = try std.process.currentDirAlloc(io, gpa);
6565 defer gpa.free(cwd);
6666 assert(mem.eql(u8, cwd, "."));
6767 }
6868 return "";
6969 }
70 const cwd = try std.process.getCwdAlloc(gpa);
70 const cwd = try std.process.currentDirAlloc(io, gpa);
7171 defer gpa.free(cwd);
7272 const resolved = try Dir.path.resolve(gpa, &.{cwd});
7373 assert(Dir.path.isAbsolute(resolved));
src/main.zig+5-5
......@@ -4775,7 +4775,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
47754775 }
47764776 }
47774777
4778 const cwd_path = try introspect.getResolvedCwd(arena);
4778 const cwd_path = try introspect.getResolvedCwd(io, arena);
47794779 const cwd_basename = fs.path.basename(cwd_path);
47804780 const sanitized_root_name = try sanitizeExampleName(arena, cwd_basename);
47814781
......@@ -5141,7 +5141,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8,
51415141
51425142 process.raiseFileDescriptorLimit();
51435143
5144 const cwd_path = try introspect.getResolvedCwd(arena);
5144 const cwd_path = try introspect.getResolvedCwd(io, arena);
51455145 const build_root = try findBuildRoot(arena, io, .{
51465146 .cwd_path = cwd_path,
51475147 .build_file = build_file,
......@@ -7077,7 +7077,7 @@ fn cmdFetch(
70777077 },
70787078 };
70797079
7080 const cwd_path = try introspect.getResolvedCwd(arena);
7080 const cwd_path = try introspect.getResolvedCwd(io, arena);
70817081
70827082 var build_root = try findBuildRoot(arena, io, .{
70837083 .cwd_path = cwd_path,
......@@ -7288,7 +7288,7 @@ const FindBuildRootOptions = struct {
72887288};
72897289
72907290fn findBuildRoot(arena: Allocator, io: Io, options: FindBuildRootOptions) !BuildRoot {
7291 const cwd_path = options.cwd_path orelse try introspect.getResolvedCwd(arena);
7291 const cwd_path = options.cwd_path orelse try introspect.getResolvedCwd(io, arena);
72927292 const build_zig_basename = if (options.build_file) |bf|
72937293 fs.path.basename(bf)
72947294 else
......@@ -7490,7 +7490,7 @@ fn writeSimpleTemplateFile(io: Io, file_name: []const u8, comptime fmt: []const
74907490}
74917491
74927492fn findTemplates(gpa: Allocator, arena: Allocator, io: Io) Templates {
7493 const cwd_path = introspect.getResolvedCwd(arena) catch |err| {
7493 const cwd_path = introspect.getResolvedCwd(io, arena) catch |err| {
74947494 fatal("unable to get cwd: {t}", .{err});
74957495 };
74967496 const self_exe_path = process.executablePathAlloc(io, arena) catch |err| {
test/standalone/child_process/main.zig+8-8
......@@ -9,7 +9,14 @@ pub fn main(init: std.process.Init.Minimal) !void {
99 };
1010 const gpa = gpa_state.allocator();
1111
12 const process_cwd_path = try std.process.getCwdAlloc(gpa);
12 var threaded: Io.Threaded = .init(gpa, .{
13 .argv0 = .init(init.args),
14 .environ = init.environ,
15 });
16 defer threaded.deinit();
17 const io = threaded.io();
18
19 const process_cwd_path = try std.process.currentDirAlloc(io, gpa);
1320 defer gpa.free(process_cwd_path);
1421
1522 var environ_map = try init.environ.createMap(gpa);
......@@ -27,13 +34,6 @@ pub fn main(init: std.process.Init.Minimal) !void {
2734 };
2835 defer if (needs_free) gpa.free(child_path);
2936
30 var threaded: Io.Threaded = .init(gpa, .{
31 .argv0 = .init(init.args),
32 .environ = init.environ,
33 });
34 defer threaded.deinit();
35 const io = threaded.io();
36
3737 var child = try std.process.spawn(io, .{
3838 .argv = &.{ child_path, "hello arg" },
3939 .stdin = .pipe,
test/standalone/posix/cwd.zig+14-13
......@@ -13,43 +13,44 @@ pub fn main(init: std.process.Init) !void {
1313 .windows => return, // POSIX is not implemented by Windows
1414 else => {},
1515 }
16 const io = init.io;
1617 const args = try init.minimal.args.toSlice(init.arena.allocator());
1718 const tmp_dir_path = args[1];
1819
1920 var tmp_dir = try Io.Dir.cwd().openDir(init.io, tmp_dir_path, .{});
2021 defer tmp_dir.close(init.io);
2122
22 try test_chdir_self();
23 try test_chdir_absolute();
24 try test_chdir_relative(init.gpa, init.io, tmp_dir);
23 try test_chdir_self(io);
24 try test_chdir_absolute(io);
25 try test_chdir_relative(init.gpa, io, tmp_dir);
2526}
2627
2728// get current working directory and expect it to match given path
28fn expect_cwd(expected_cwd: []const u8) !void {
29fn expect_cwd(io: Io, expected_cwd: []const u8) !void {
2930 var cwd_buf: [path_max]u8 = undefined;
30 const actual_cwd = try std.posix.getcwd(cwd_buf[0..]);
31 const actual_cwd = cwd_buf[0..try std.process.currentDir(io, &cwd_buf)];
3132 try std.testing.expectEqualStrings(actual_cwd, expected_cwd);
3233}
3334
34fn test_chdir_self() !void {
35fn test_chdir_self(io: Io) !void {
3536 var old_cwd_buf: [path_max]u8 = undefined;
36 const old_cwd = try std.posix.getcwd(old_cwd_buf[0..]);
37 const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
3738
3839 // Try changing to the current directory
3940 try std.Io.Threaded.chdir(old_cwd);
40 try expect_cwd(old_cwd);
41 try expect_cwd(io, old_cwd);
4142}
4243
43fn test_chdir_absolute() !void {
44fn test_chdir_absolute(io: Io) !void {
4445 var old_cwd_buf: [path_max]u8 = undefined;
45 const old_cwd = try std.posix.getcwd(old_cwd_buf[0..]);
46 const old_cwd = old_cwd_buf[0..try std.process.currentDir(io, &old_cwd_buf)];
4647
4748 const parent = std.fs.path.dirname(old_cwd) orelse unreachable; // old_cwd should be absolute
4849
4950 // Try changing to the parent via a full path
5051 try std.Io.Threaded.chdir(parent);
5152
52 try expect_cwd(parent);
53 try expect_cwd(io, parent);
5354}
5455
5556fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
......@@ -61,7 +62,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
6162
6263 // Capture base working directory path, to build expected full path
6364 var base_cwd_buf: [path_max]u8 = undefined;
64 const base_cwd = try std.posix.getcwd(base_cwd_buf[0..]);
65 const base_cwd = base_cwd_buf[0..try std.process.currentDir(io, &base_cwd_buf)];
6566
6667 const expected_path = try std.fs.path.resolve(gpa, &.{ base_cwd, subdir_path });
6768 defer gpa.free(expected_path);
......@@ -70,7 +71,7 @@ fn test_chdir_relative(gpa: Allocator, io: Io, tmp_dir: Io.Dir) !void {
7071 try std.Io.Threaded.chdir(subdir_path);
7172
7273 var new_cwd_buf: [path_max]u8 = undefined;
73 const new_cwd = try std.posix.getcwd(new_cwd_buf[0..]);
74 const new_cwd = new_cwd_buf[0..try std.process.currentDir(io, &new_cwd_buf)];
7475
7576 // On Windows, fs.path.resolve returns an uppercase drive letter, but the drive letter returned by getcwd may be lowercase
7677 const resolved_cwd = try std.fs.path.resolve(gpa, &.{new_cwd});
test/standalone/self_exe_symlink/create-symlink.zig+1-1
......@@ -9,7 +9,7 @@ pub fn main(init: std.process.Init) !void {
99 const exe_path = it.next() orelse unreachable;
1010 const symlink_path = it.next() orelse unreachable;
1111
12 const cwd = try std.process.getCwdAlloc(init.arena.allocator());
12 const cwd = try std.process.currentDirAlloc(io, init.arena.allocator());
1313
1414 // If `exe_path` is relative to our cwd, we need to convert it to be relative to the dirname of `symlink_path`.
1515 const exe_rel_path = try std.fs.path.relative(gpa, cwd, init.environ_map, std.fs.path.dirname(symlink_path) orelse ".", exe_path);
test/standalone/windows_paths/relative.zig+1-1
......@@ -4,7 +4,7 @@ pub fn main(init: std.process.Init) !void {
44 const arena = init.arena.allocator();
55 const args = try init.minimal.args.toSlice(arena);
66 const io = init.io;
7 const cwd_path = try std.process.getCwdAlloc(arena);
7 const cwd_path = try std.process.currentDirAlloc(io, arena);
88
99 if (args.len < 3) return error.MissingArgs;
1010
test/standalone/windows_paths/test.zig+1-1
......@@ -10,7 +10,7 @@ pub fn main(init: std.process.Init) !void {
1010
1111 const exe_path = args[1];
1212
13 const cwd_path = try std.process.getCwdAlloc(arena);
13 const cwd_path = try std.process.currentDirAlloc(io, arena);
1414 const parsed_cwd_path = std.fs.path.parsePathWindows(u8, cwd_path);
1515
1616 if (parsed_cwd_path.kind == .drive_absolute and !std.ascii.isAlphabetic(cwd_path[0])) {
test/standalone/windows_spawn/main.zig+1-1
......@@ -8,7 +8,7 @@ const utf16Literal = std.unicode.utf8ToUtf16LeStringLiteral;
88pub fn main(init: std.process.Init) !void {
99 const gpa = init.gpa;
1010 const io = init.io;
11 const process_cwd_path = try std.process.getCwdAlloc(init.arena.allocator());
11 const process_cwd_path = try std.process.currentDirAlloc(io, init.arena.allocator());
1212 var initial_process_cwd = try Io.Dir.cwd().openDir(io, ".", .{});
1313 defer initial_process_cwd.close(io);
1414
tools/doctest.zig+1-1
......@@ -33,7 +33,7 @@ pub fn main(init: std.process.Init) !void {
3333 const arena = init.arena.allocator();
3434 const io = init.io;
3535 const environ_map = init.environ_map;
36 const cwd_path = try std.process.getCwdAlloc(arena);
36 const cwd_path = try std.process.currentDirAlloc(io, arena);
3737
3838 try environ_map.put("CLICOLOR_FORCE", "1");
3939
tools/incr-check.zig+1-1
......@@ -32,7 +32,7 @@ pub fn main(init: std.process.Init) !void {
3232 const arena = init.arena.allocator();
3333 const io = init.io;
3434 const environ_map = init.environ_map;
35 const cwd_path = try std.process.getCwdAlloc(arena);
35 const cwd_path = try std.process.currentDirAlloc(io, arena);
3636
3737 var opt_zig_exe: ?[]const u8 = null;
3838 var opt_input_file_name: ?[]const u8 = null;
tools/process_headers.zig+1-1
......@@ -145,7 +145,7 @@ pub fn main(init: std.process.Init) !void {
145145 const arena = init.arena.allocator();
146146 const io = init.io;
147147 const args = try init.minimal.args.toSlice(arena);
148 const cwd_path = try std.process.getCwdAlloc(arena);
148 const cwd_path = try std.process.currentDirAlloc(io, arena);
149149 const environ_map = init.environ_map;
150150
151151 var search_paths = std.array_list.Managed([]const u8).init(arena);
tools/update-linux-headers.zig+1-1
......@@ -146,7 +146,7 @@ pub fn main(init: std.process.Init) !void {
146146 const io = init.io;
147147 const args = try init.minimal.args.toSlice(arena);
148148 const environ_map = init.environ_map;
149 const cwd = try std.process.getCwdAlloc(arena);
149 const cwd = try std.process.currentDirAlloc(io, arena);
150150
151151 var search_paths = std.array_list.Managed([]const u8).init(arena);
152152 var opt_out_dir: ?[]const u8 = null;