Commit 68b87918df9ad82cf3161f323c55f2e238319922 | zig

author	Ryan Liptak <squeek502@hotmail.com> 2024-02-13 16:56:50-08:00
committer	Ryan Liptak <squeek502@hotmail.com> 2024-02-24 14:05:24-08:00
log	68b87918df9ad82cf3161f323c55f2e238319922
tree	c802aea2b636236f767e6c1cdd864f01c2b47d15
parent	f6b6b8a4ae4780f21c45824d34d8e14b3c3b5037

Fix handling of Windows (WTF-16) and WASI (UTF-8) paths

Windows paths now use WTF-16 <-> WTF-8 conversion everywhere, which is lossless. Previously, conversion of ill-formed UTF-16 paths would either fail or invoke illegal behavior.

WASI paths must be valid UTF-8, and the relevant function calls have been updated to handle the possibility of failure due to paths not being encoded/encodable as valid UTF-8.

Closes #18694
Closes #1774
Closes #2565

20 files changed, 1000 insertions(+), 1109 deletions(-)

deps
- aro
  - aro
    Compilation.zig
    Driver.zig
lib
- std
  - Build
    Cache.zig
  - Thread.zig
  - child_process.zig
  - fs.zig
  - fs
    Dir.zig
    File.zig
    path.zig
    test.zig
    watch.zig
  - os.zig
  - os
    windows.zig
  - process.zig
  - unicode.zig
  - zig
    system.zig
    system
    NativePaths.zig
src

deps/aro/aro/Compilation.zig+1-1

...	@@ -69,7 +69,7 @@ pub const Environment = struct {	...	@@ -69,7 +69,7 @@ pub const Environment = struct {
69	const val: ?[]const u8 = std.process.getEnvVarOwned(allocator, env_var_name) catch \|err\| switch (err) {	69	const val: ?[]const u8 = std.process.getEnvVarOwned(allocator, env_var_name) catch \|err\| switch (err) {
70	error.OutOfMemory => \|e\| return e,	70	error.OutOfMemory => \|e\| return e,
71	error.EnvironmentVariableNotFound => null,	71	error.EnvironmentVariableNotFound => null,
72	error.InvalidUtf8 => null,	72	error.InvalidWtf8 => null,
73	};	73	};
74	@field(env, field.name) = val;	74	@field(env, field.name) = val;
75	}	75	}

deps/aro/aro/Driver.zig+2-1

...	@@ -523,7 +523,8 @@ pub fn errorDescription(e: anyerror) []const u8 {	...	@@ -523,7 +523,8 @@ pub fn errorDescription(e: anyerror) []const u8 {
523	error.NotDir => "is not a directory",	523	error.NotDir => "is not a directory",
524	error.NotOpenForReading => "file is not open for reading",	524	error.NotOpenForReading => "file is not open for reading",
525	error.NotOpenForWriting => "file is not open for writing",	525	error.NotOpenForWriting => "file is not open for writing",
526	error.InvalidUtf8 => "input is not valid UTF-8",	526	error.InvalidUtf8 => "path is not valid UTF-8",
		527	error.InvalidWtf8 => "path is not valid WTF-8",
527	error.FileBusy => "file is busy",	528	error.FileBusy => "file is busy",
528	error.NameTooLong => "file name is too long",	529	error.NameTooLong => "file name is too long",
529	error.AccessDenied => "access denied",	530	error.AccessDenied => "access denied",

lib/std/Build/Cache.zig+1-1

...	@@ -162,7 +162,7 @@ fn findPrefixResolved(cache: *const Cache, resolved_path: []u8) !PrefixedPath {	...	@@ -162,7 +162,7 @@ fn findPrefixResolved(cache: *const Cache, resolved_path: []u8) !PrefixedPath {
162	fn getPrefixSubpath(allocator: Allocator, prefix: []const u8, path: []u8) ![]u8 {	162	fn getPrefixSubpath(allocator: Allocator, prefix: []const u8, path: []u8) ![]u8 {
163	const relative = try std.fs.path.relative(allocator, prefix, path);	163	const relative = try std.fs.path.relative(allocator, prefix, path);
164	errdefer allocator.free(relative);	164	errdefer allocator.free(relative);
165	var component_iterator = std.fs.path.NativeUtf8ComponentIterator.init(relative) catch {	165	var component_iterator = std.fs.path.NativeComponentIterator.init(relative) catch {
166	return error.NotASubPath;	166	return error.NotASubPath;
167	};	167	};
168	if (component_iterator.root() != null) {	168	if (component_iterator.root() != null) {

lib/std/Thread.zig+4-9

 @@ -91,7 +91,7 @@ pub fn setName(self: Thread, name: []const u8) SetNameError!void {
         },
         .windows => {
             var buf: [max_name_len]u16 = undefined;
-            const len = try std.unicode.utf8ToUtf16Le(&buf, name);
+            const len = try std.unicode.wtf8ToWtf16Le(&buf, name);
             const byte_len = math.cast(c_ushort, len * 2) orelse return error.NameTooLong;
             // Note: NT allocates its own copy, no use-after-free here.
 @@ -157,17 +157,12 @@ pub fn setName(self: Thread, name: []const u8) SetNameError!void {
 }
 pub const GetNameError = error{
-    // For Windows, the name is converted from UTF16 to UTF8
-    CodepointTooLarge,
-    Utf8CannotEncodeSurrogateHalf,
-    DanglingSurrogateHalf,
-    ExpectedSecondSurrogateHalf,
-    UnexpectedSecondSurrogateHalf,
     Unsupported,
     Unexpected,
 } || os.PrctlError || os.ReadError || std.fs.File.OpenError || std.fmt.BufPrintError;
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]const u8 {
     buffer_ptr[max_name_len] = 0;
     var buffer: [:0]u8 = buffer_ptr;
 @@ -213,7 +208,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
             )) {
                 .SUCCESS => {
                     const string = @as(*const os.windows.UNICODE_STRING, @ptrCast(&buf));
-                    const len = try std.unicode.utf16LeToUtf8(buffer, string.Buffer[0 .. string.Length / 2]);
+                    const len = std.unicode.wtf16LeToWtf8(buffer, string.Buffer[0 .. string.Length / 2]);
                     return if (len > 0) buffer[0..len] else null;
                 },
                 .NOT_IMPLEMENTED => return error.Unsupported,

lib/std/child_process.zig+21-22

 @@ -129,10 +129,9 @@ pub const ChildProcess = struct {
         /// POSIX-only. `StdIo.Ignore` was selected and opening `/dev/null` returned ENODEV.
         NoDevice,
-        /// Windows-only. One of:
+        /// Windows-only. `cwd` or `argv` was provided and it was invalid WTF-8.
-        /// * `cwd` was provided and it could not be re-encoded into UTF16LE, or
+        /// https://simonsapin.github.io/wtf-8/
-        /// * The `PATH` or `PATHEXT` environment variable contained invalid UTF-8.
+        InvalidWtf8,
-        InvalidUtf8,
         /// Windows-only. `cwd` was provided, but the path did not exist when spawning the child process.
         CurrentWorkingDirectoryUnlinked,
 @@ -767,7 +766,7 @@ pub const ChildProcess = struct {
         };
         var piProcInfo: windows.PROCESS_INFORMATION = undefined;
-        const cwd_w = if (self.cwd) |cwd| try unicode.utf8ToUtf16LeAllocZ(self.allocator, cwd) else null;
+        const cwd_w = if (self.cwd) |cwd| try unicode.wtf8ToWtf16LeAllocZ(self.allocator, cwd) else null;
         defer if (cwd_w) |cwd| self.allocator.free(cwd);
         const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
 @@ -775,8 +774,8 @@ pub const ChildProcess = struct {
         defer if (maybe_envp_buf) |envp_buf| self.allocator.free(envp_buf);
         const envp_ptr = if (maybe_envp_buf) |envp_buf| envp_buf.ptr else null;
-        const app_name_utf8 = self.argv[0];
+        const app_name_wtf8 = self.argv[0];
-        const app_name_is_absolute = fs.path.isAbsolute(app_name_utf8);
+        const app_name_is_absolute = fs.path.isAbsolute(app_name_wtf8);
         // the cwd set in ChildProcess is in effect when choosing the executable path
         // to match posix semantics
 @@ -785,11 +784,11 @@ pub const ChildProcess = struct {
             // If the app name is absolute, then we need to use its dirname as the cwd
             if (app_name_is_absolute) {
                 cwd_path_w_needs_free = true;
-                const dir = fs.path.dirname(app_name_utf8).?;
+                const dir = fs.path.dirname(app_name_wtf8).?;
-                break :x try unicode.utf8ToUtf16LeAllocZ(self.allocator, dir);
+                break :x try unicode.wtf8ToWtf16LeAllocZ(self.allocator, dir);
             } else if (self.cwd) |cwd| {
                 cwd_path_w_needs_free = true;
-                break :x try unicode.utf8ToUtf16LeAllocZ(self.allocator, cwd);
+                break :x try unicode.wtf8ToWtf16LeAllocZ(self.allocator, cwd);
             } else {
                 break :x &[_:0]u16{}; // empty for cwd
             }
 @@ -800,19 +799,19 @@ pub const ChildProcess = struct {
         // into the basename and dirname and use the dirname as an addition to the cwd
         // path. This is because NtQueryDirectoryFile cannot accept FileName params with
         // path separators.
-        const app_basename_utf8 = fs.path.basename(app_name_utf8);
+        const app_basename_wtf8 = fs.path.basename(app_name_wtf8);
         // If the app name is absolute, then the cwd will already have the app's dirname in it,
         // so only populate app_dirname if app name is a relative path with > 0 path separators.
-        const maybe_app_dirname_utf8 = if (!app_name_is_absolute) fs.path.dirname(app_name_utf8) else null;
+        const maybe_app_dirname_wtf8 = if (!app_name_is_absolute) fs.path.dirname(app_name_wtf8) else null;
         const app_dirname_w: ?[:0]u16 = x: {
-            if (maybe_app_dirname_utf8) |app_dirname_utf8| {
+            if (maybe_app_dirname_wtf8) |app_dirname_wtf8| {
-                break :x try unicode.utf8ToUtf16LeAllocZ(self.allocator, app_dirname_utf8);
+                break :x try unicode.wtf8ToWtf16LeAllocZ(self.allocator, app_dirname_wtf8);
             }
             break :x null;
         };
         defer if (app_dirname_w != null) self.allocator.free(app_dirname_w.?);
-        const app_name_w = try unicode.utf8ToUtf16LeAllocZ(self.allocator, app_basename_utf8);
+        const app_name_w = try unicode.wtf8ToWtf16LeAllocZ(self.allocator, app_basename_wtf8);
         defer self.allocator.free(app_name_w);
         const cmd_line_w = argvToCommandLineWindows(self.allocator, self.argv) catch |err| switch (err) {
 @@ -1173,7 +1172,7 @@ const CreateProcessSupportedExtension = enum {
     exe,
 };
-/// Case-insensitive UTF-16 lookup
+/// Case-insensitive WTF-16 lookup
 fn windowsCreateProcessSupportsExtension(ext: []const u16) ?CreateProcessSupportedExtension {
     if (ext.len != 4) return null;
     const State = enum {
 @@ -1237,7 +1236,7 @@ test "windowsCreateProcessSupportsExtension" {
     try std.testing.expect(windowsCreateProcessSupportsExtension(&[_]u16{ '.', 'e', 'X', 'e', 'c' }) == null);
 }
-pub const ArgvToCommandLineError = error{ OutOfMemory, InvalidUtf8, InvalidArg0 };
+pub const ArgvToCommandLineError = error{ OutOfMemory, InvalidWtf8, InvalidArg0 };
 /// Serializes `argv` to a Windows command-line string suitable for passing to a child process and
 /// parsing by the `CommandLineToArgvW` algorithm. The caller owns the returned slice.
 @@ -1320,7 +1319,7 @@ pub fn argvToCommandLineWindows(
         }
     }
-    return try unicode.utf8ToUtf16LeAllocZ(allocator, buf.items);
+    return try unicode.wtf8ToWtf16LeAllocZ(allocator, buf.items);
 }
 test "argvToCommandLineWindows" {
 @@ -1386,7 +1385,7 @@ fn testArgvToCommandLineWindows(argv: []const []const u8, expected_cmd_line: []c
     const cmd_line_w = try argvToCommandLineWindows(std.testing.allocator, argv);
     defer std.testing.allocator.free(cmd_line_w);
-    const cmd_line = try unicode.utf16LeToUtf8Alloc(std.testing.allocator, cmd_line_w);
+    const cmd_line = try unicode.wtf16LeToWtf8Alloc(std.testing.allocator, cmd_line_w);
     defer std.testing.allocator.free(cmd_line);
     try std.testing.expectEqualStrings(expected_cmd_line, cmd_line);
 @@ -1424,7 +1423,7 @@ fn windowsMakeAsyncPipe(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *cons
             "\\\\.\\pipe\\zig-childprocess-{d}-{d}",
             .{ windows.kernel32.GetCurrentProcessId(), pipe_name_counter.fetchAdd(1, .Monotonic) },
         ) catch unreachable;
-        const len = std.unicode.utf8ToUtf16Le(&tmp_bufw, pipe_path) catch unreachable;
+        const len = std.unicode.wtf8ToWtf16Le(&tmp_bufw, pipe_path) catch unreachable;
         tmp_bufw[len] = 0;
         break :blk tmp_bufw[0..len :0];
     };
 @@ -1521,10 +1520,10 @@ pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: *const EnvMap) !
     var it = env_map.iterator();
     var i: usize = 0;
     while (it.next()) |pair| {
-        i += try unicode.utf8ToUtf16Le(result[i..], pair.key_ptr.*);
+        i += try unicode.wtf8ToWtf16Le(result[i..], pair.key_ptr.*);
         result[i] = '=';
         i += 1;
-        i += try unicode.utf8ToUtf16Le(result[i..], pair.value_ptr.*);
+        i += try unicode.wtf8ToWtf16Le(result[i..], pair.value_ptr.*);
         result[i] = 0;
         i += 1;
     }

lib/std/fs.zig+139-38

 @@ -31,18 +31,21 @@ pub const realpathW = os.realpathW;
 pub const getAppDataDir = @import("fs/get_app_data_dir.zig").getAppDataDir;
 pub const GetAppDataDirError = @import("fs/get_app_data_dir.zig").GetAppDataDirError;
-/// This represents the maximum size of a UTF-8 encoded file path that the
+/// This represents the maximum size of a `[]u8` file path that the
 /// operating system will accept. Paths, including those returned from file
 /// system operations, may be longer than this length, but such paths cannot
 /// be successfully passed back in other file system operations. However,
 /// all path components returned by file system operations are assumed to
-/// fit into a UTF-8 encoded array of this length.
+/// fit into a `u8` array of this length.
 /// The byte count includes room for a null sentinel byte.
+/// On Windows, `[]u8` file paths are encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `[]u8` file paths are encoded as valid UTF-8.
+/// On other platforms, `[]u8` file paths are opaque sequences of bytes with no particular encoding.
 pub const MAX_PATH_BYTES = switch (builtin.os.tag) {
     .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten => os.PATH_MAX,
-    // Each UTF-16LE character may be expanded to 3 UTF-8 bytes.
+    // Each WTF-16LE code unit may be expanded to 3 WTF-8 bytes.
-    // If it would require 4 UTF-8 bytes, then there would be a surrogate
+    // If it would require 4 WTF-8 bytes, then there would be a surrogate
-    // pair in the UTF-16LE, and we (over)account 3 bytes for it that way.
+    // pair in the WTF-16LE, and we (over)account 3 bytes for it that way.
     // +1 for the null byte at the end, which can be encoded in 1 byte.
     .windows => os.windows.PATH_MAX_WIDE * 3 + 1,
     // TODO work out what a reasonable value we should use here
 @@ -53,18 +56,21 @@ pub const MAX_PATH_BYTES = switch (builtin.os.tag) {
         @compileError("PATH_MAX not implemented for " ++ @tagName(builtin.os.tag)),
 };
-/// This represents the maximum size of a UTF-8 encoded file name component that
+/// This represents the maximum size of a `[]u8` file name component that
 /// the platform's common file systems support. File name components returned by file system
-/// operations are likely to fit into a UTF-8 encoded array of this length, but
+/// operations are likely to fit into a `u8` array of this length, but
 /// (depending on the platform) this assumption may not hold for every configuration.
 /// The byte count does not include a null sentinel byte.
+/// On Windows, `[]u8` file name components are encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, file name components are encoded as valid UTF-8.
+/// On other platforms, `[]u8` components are an opaque sequence of bytes with no particular encoding.
 pub const MAX_NAME_BYTES = switch (builtin.os.tag) {
     .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .illumos => os.NAME_MAX,
     // Haiku's NAME_MAX includes the null terminator, so subtract one.
     .haiku => os.NAME_MAX - 1,
-    // Each UTF-16LE character may be expanded to 3 UTF-8 bytes.
+    // Each WTF-16LE character may be expanded to 3 WTF-8 bytes.
-    // If it would require 4 UTF-8 bytes, then there would be a surrogate
+    // If it would require 4 WTF-8 bytes, then there would be a surrogate
-    // pair in the UTF-16LE, and we (over)account 3 bytes for it that way.
+    // pair in the WTF-16LE, and we (over)account 3 bytes for it that way.
     .windows => os.windows.NAME_MAX * 3,
     // For WASI, the MAX_NAME will depend on the host OS, so it needs to be
     // as large as the largest MAX_NAME_BYTES (Windows) in order to work on any host OS.
 @@ -86,6 +92,9 @@ pub const base64_decoder = base64.Base64Decoder.init(base64_alphabet, null);
 /// TODO remove the allocator requirement from this API
 /// TODO move to Dir
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn atomicSymLink(allocator: Allocator, existing_path: []const u8, new_path: []const u8) !void {
     if (cwd().symLink(existing_path, new_path, .{})) {
         return;
 @@ -117,6 +126,9 @@ pub fn atomicSymLink(allocator: Allocator, existing_path: []const u8, new_path:
 /// Same as `Dir.updateFile`, except asserts that both `source_path` and `dest_path`
 /// are absolute. See `Dir.updateFile` for a function that operates on both
 /// absolute and relative paths.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn updateFileAbsolute(
     source_path: []const u8,
     dest_path: []const u8,
 @@ -131,6 +143,9 @@ pub fn updateFileAbsolute(
 /// Same as `Dir.copyFile`, except asserts that both `source_path` and `dest_path`
 /// are absolute. See `Dir.copyFile` for a function that operates on both
 /// absolute and relative paths.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn copyFileAbsolute(
     source_path: []const u8,
     dest_path: []const u8,
 @@ -145,24 +160,30 @@ pub fn copyFileAbsolute(
 /// Create a new directory, based on an absolute path.
 /// Asserts that the path is absolute. See `Dir.makeDir` for a function that operates
 /// on both absolute and relative paths.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn makeDirAbsolute(absolute_path: []const u8) !void {
     assert(path.isAbsolute(absolute_path));
     return os.mkdir(absolute_path, Dir.default_mode);
 }
-/// Same as `makeDirAbsolute` except the parameter is a null-terminated UTF-8-encoded string.
+/// Same as `makeDirAbsolute` except the parameter is null-terminated.
 pub fn makeDirAbsoluteZ(absolute_path_z: [*:0]const u8) !void {
     assert(path.isAbsoluteZ(absolute_path_z));
     return os.mkdirZ(absolute_path_z, Dir.default_mode);
 }
-/// Same as `makeDirAbsolute` except the parameter is a null-terminated WTF-16-encoded string.
+/// Same as `makeDirAbsolute` except the parameter is a null-terminated WTF-16 LE-encoded string.
 pub fn makeDirAbsoluteW(absolute_path_w: [*:0]const u16) !void {
     assert(path.isAbsoluteWindowsW(absolute_path_w));
     return os.mkdirW(absolute_path_w, Dir.default_mode);
 }
 /// Same as `Dir.deleteDir` except the path is absolute.
+/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `dir_path` should be encoded as valid UTF-8.
+/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
 pub fn deleteDirAbsolute(dir_path: []const u8) !void {
     assert(path.isAbsolute(dir_path));
     return os.rmdir(dir_path);
 @@ -181,6 +202,9 @@ pub fn deleteDirAbsoluteW(dir_path: [*:0]const u16) !void {
 }
 /// Same as `Dir.rename` except the paths are absolute.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn renameAbsolute(old_path: []const u8, new_path: []const u8) !void {
     assert(path.isAbsolute(old_path));
     assert(path.isAbsolute(new_path));
 @@ -211,7 +235,7 @@ pub fn renameZ(old_dir: Dir, old_sub_path_z: [*:0]const u8, new_dir: Dir, new_su
     return os.renameatZ(old_dir.fd, old_sub_path_z, new_dir.fd, new_sub_path_z);
 }
-/// Same as `rename` except the parameters are UTF16LE, NT prefixed.
+/// Same as `rename` except the parameters are WTF16LE, NT prefixed.
 /// This function is Windows-only.
 pub fn renameW(old_dir: Dir, old_sub_path_w: []const u16, new_dir: Dir, new_sub_path_w: []const u16) !void {
     return os.renameatW(old_dir.fd, old_sub_path_w, new_dir.fd, new_sub_path_w);
 @@ -240,6 +264,9 @@ pub fn defaultWasiCwd() std.os.wasi.fd_t {
 /// See `openDirAbsoluteZ` for a function that accepts a null-terminated path.
 ///
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn openDirAbsolute(absolute_path: []const u8, flags: Dir.OpenDirOptions) File.OpenError!Dir {
     assert(path.isAbsolute(absolute_path));
     return cwd().openDir(absolute_path, flags);
 @@ -262,6 +289,9 @@ pub fn openDirAbsoluteW(absolute_path_c: [*:0]const u16, flags: Dir.OpenDirOptio
 /// operates on both absolute and relative paths.
 /// Asserts that the path parameter has no null bytes. See `openFileAbsoluteZ` for a function
 /// that accepts a null-terminated path.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn openFileAbsolute(absolute_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
     assert(path.isAbsolute(absolute_path));
     return cwd().openFile(absolute_path, flags);
 @@ -280,11 +310,13 @@ pub fn openFileAbsoluteW(absolute_path_w: []const u16, flags: File.OpenFlags) Fi
 }
 /// Test accessing `path`.
-/// `path` is UTF-8-encoded.
 /// Be careful of Time-Of-Check-Time-Of-Use race conditions when using this function.
 /// For example, instead of testing if a file exists and then opening it, just
 /// open it and handle the error for file not found.
 /// See `accessAbsoluteZ` for a function that accepts a null-terminated path.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn accessAbsolute(absolute_path: []const u8, flags: File.OpenFlags) Dir.AccessError!void {
     assert(path.isAbsolute(absolute_path));
     try cwd().access(absolute_path, flags);
 @@ -306,6 +338,9 @@ pub fn accessAbsoluteW(absolute_path: [*:0]const u16, flags: File.OpenFlags) Dir
 /// operates on both absolute and relative paths.
 /// Asserts that the path parameter has no null bytes. See `createFileAbsoluteC` for a function
 /// that accepts a null-terminated path.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn createFileAbsolute(absolute_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
     assert(path.isAbsolute(absolute_path));
     return cwd().createFile(absolute_path, flags);
 @@ -327,6 +362,9 @@ pub fn createFileAbsoluteW(absolute_path_w: [*:0]const u16, flags: File.CreateFl
 /// Asserts that the path is absolute. See `Dir.deleteFile` for a function that
 /// operates on both absolute and relative paths.
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn deleteFileAbsolute(absolute_path: []const u8) Dir.DeleteFileError!void {
     assert(path.isAbsolute(absolute_path));
     return cwd().deleteFile(absolute_path);
 @@ -349,6 +387,9 @@ pub fn deleteFileAbsoluteW(absolute_path_w: [*:0]const u16) Dir.DeleteFileError!
 /// Asserts that the path is absolute. See `Dir.deleteTree` for a function that
 /// operates on both absolute and relative paths.
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `absolute_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `absolute_path` should be encoded as valid UTF-8.
+/// On other platforms, `absolute_path` is an opaque sequence of bytes with no particular encoding.
 pub fn deleteTreeAbsolute(absolute_path: []const u8) !void {
     assert(path.isAbsolute(absolute_path));
     const dirname = path.dirname(absolute_path) orelse return error{
 @@ -364,6 +405,9 @@ pub fn deleteTreeAbsolute(absolute_path: []const u8) !void {
 }
 /// Same as `Dir.readLink`, except it asserts the path is absolute.
+/// On Windows, `pathname` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `pathname` should be encoded as valid UTF-8.
+/// On other platforms, `pathname` is an opaque sequence of bytes with no particular encoding.
 pub fn readLinkAbsolute(pathname: []const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {
     assert(path.isAbsolute(pathname));
     return os.readlink(pathname, buffer);
 @@ -387,6 +431,9 @@ pub fn readLinkAbsoluteZ(pathname_c: [*:0]const u8, buffer: *[MAX_PATH_BYTES]u8)
 /// one; the latter case is known as a dangling link.
 /// If `sym_link_path` exists, it will not be overwritten.
 /// See also `symLinkAbsoluteZ` and `symLinkAbsoluteW`.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn symLinkAbsolute(
     target_path: []const u8,
     sym_link_path: []const u8,
 @@ -402,7 +449,7 @@ pub fn symLinkAbsolute(
     return os.symlink(target_path, sym_link_path);
 }
-/// Windows-only. Same as `symLinkAbsolute` except the parameters are null-terminated, WTF16 encoded.
+/// Windows-only. Same as `symLinkAbsolute` except the parameters are null-terminated, WTF16 LE encoded.
 /// Note that this function will by default try creating a symbolic link to a file. If you would
 /// like to create a symbolic link to a directory, specify this with `SymLinkFlags{ .is_directory = true }`.
 /// See also `symLinkAbsolute`, `symLinkAbsoluteZ`.
 @@ -426,27 +473,14 @@ pub fn symLinkAbsoluteZ(
     assert(path.isAbsoluteZ(target_path_c));
     assert(path.isAbsoluteZ(sym_link_path_c));
     if (builtin.os.tag == .windows) {
-        const target_path_w = try os.windows.cStrToWin32PrefixedFileW(target_path_c);
+        const target_path_w = try os.windows.cStrToPrefixedFileW(null, target_path_c);
-        const sym_link_path_w = try os.windows.cStrToWin32PrefixedFileW(sym_link_path_c);
+        const sym_link_path_w = try os.windows.cStrToPrefixedFileW(null, sym_link_path_c);
-        return os.windows.CreateSymbolicLink(sym_link_path_w.span(), target_path_w.span(), flags.is_directory);
+        return os.windows.CreateSymbolicLink(null, sym_link_path_w.span(), target_path_w.span(), flags.is_directory);
     }
     return os.symlinkZ(target_path_c, sym_link_path_c);
 }
-pub const OpenSelfExeError = error{
+pub const OpenSelfExeError = os.OpenError || SelfExePathError || os.FlockError;
-    SharingViolation,
-    PathAlreadyExists,
-    FileNotFound,
-    AccessDenied,
-    PipeBusy,
-    NameTooLong,
-    /// On Windows, file paths must be valid Unicode.
-    InvalidUtf8,
-    /// On Windows, file paths cannot contain these characters:
-    /// '/', '*', '?', '"', '<', '>', '|'
-    BadPathName,
-    Unexpected,
-} || os.OpenError || SelfExePathError || os.FlockError;
 pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
     if (builtin.os.tag == .linux) {
 @@ -469,7 +503,45 @@ pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
     return openFileAbsoluteZ(buf[0..self_exe_path.len :0].ptr, flags);
 }
-pub const SelfExePathError = os.ReadLinkError || os.SysCtlError || os.RealPathError;
+// This is os.ReadLinkError || os.RealPathError with impossible errors excluded
+pub const SelfExePathError = error{
+    FileNotFound,
+    AccessDenied,
+    NameTooLong,
+    NotSupported,
+    NotDir,
+    SymLinkLoop,
+    InputOutput,
+    FileTooBig,
+    IsDir,
+    ProcessFdQuotaExceeded,
+    SystemFdQuotaExceeded,
+    NoDevice,
+    SystemResources,
+    NoSpaceLeft,
+    FileSystem,
+    BadPathName,
+    DeviceBusy,
+    SharingViolation,
+    PipeBusy,
+    NotLink,
+    PathAlreadyExists,
+    InvalidHandle,
+    /// On Windows, `\\server` or `\\server\share` was not found.
+    NetworkNotFound,
+    /// On Windows, antivirus software is enabled by default. It can be
+    /// disabled, but Windows Update sometimes ignores the user's preference
+    /// and re-enables it. When enabled, antivirus software on Windows
+    /// intercepts file system operations and makes them significantly slower
+    /// in addition to possibly failing with this error code.
+    AntivirusInterference,
+    /// On Windows, the volume does not contain a recognized file system. File
+    /// system drivers might not be loaded, or the volume may be corrupt.
+    UnrecognizedVolume,
+} || os.SysCtlError;
 /// `selfExePath` except allocates the result on the heap.
 /// Caller owns returned memory.
 @@ -491,6 +563,8 @@ pub fn selfExePathAlloc(allocator: Allocator) ![]u8 {
 /// This function may return an error if the current executable
 /// was deleted after spawning.
 /// Returned value is a slice of out_buffer.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 ///
 /// On Linux, depends on procfs being mounted. If the currently executing binary has
 /// been deleted, the file path looks something like `/a/b/c/exe (deleted)`.
 @@ -505,15 +579,31 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
         if (rc != 0) return error.NameTooLong;
         var real_path_buf: [MAX_PATH_BYTES]u8 = undefined;
-        const real_path = try std.os.realpathZ(&symlink_path_buf, &real_path_buf);
+        const real_path = std.os.realpathZ(&symlink_path_buf, &real_path_buf) catch |err| switch (err) {
+            error.InvalidWtf8 => unreachable, // Windows-only
+            error.NetworkNotFound => unreachable, // Windows-only
+            else => |e| return e,
+        };
         if (real_path.len > out_buffer.len) return error.NameTooLong;
         const result = out_buffer[0..real_path.len];
         @memcpy(result, real_path);
         return result;
     }
     switch (builtin.os.tag) {
-        .linux => return os.readlinkZ("/proc/self/exe", out_buffer),
+        .linux => return os.readlinkZ("/proc/self/exe", out_buffer) catch |err| switch (err) {
-        .solaris, .illumos => return os.readlinkZ("/proc/self/path/a.out", out_buffer),
+            error.InvalidUtf8 => unreachable, // WASI-only
+            error.InvalidWtf8 => unreachable, // Windows-only
+            error.UnsupportedReparsePointType => unreachable, // Windows-only
+            error.NetworkNotFound => unreachable, // Windows-only
+            else => |e| return e,
+        },
+        .solaris, .illumos => return os.readlinkZ("/proc/self/path/a.out", out_buffer) catch |err| switch (err) {
+            error.InvalidUtf8 => unreachable, // WASI-only
+            error.InvalidWtf8 => unreachable, // Windows-only
+            error.UnsupportedReparsePointType => unreachable, // Windows-only
+            error.NetworkNotFound => unreachable, // Windows-only
+            else => |e| return e,
+        },
         .freebsd, .dragonfly => {
             var mib = [4]c_int{ os.CTL.KERN, os.KERN.PROC, os.KERN.PROC_PATHNAME, -1 };
             var out_len: usize = out_buffer.len;
 @@ -537,7 +627,11 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
             if (mem.indexOf(u8, argv0, "/") != null) {
                 // argv[0] is a path (relative or absolute): use realpath(3) directly
                 var real_path_buf: [MAX_PATH_BYTES]u8 = undefined;
-                const real_path = try os.realpathZ(os.argv[0], &real_path_buf);
+                const real_path = os.realpathZ(os.argv[0], &real_path_buf) catch |err| switch (err) {
+                    error.InvalidWtf8 => unreachable, // Windows-only
+                    error.NetworkNotFound => unreachable, // Windows-only
+                    else => |e| return e,
+                };
                 if (real_path.len > out_buffer.len)
                     return error.NameTooLong;
                 const result = out_buffer[0..real_path.len];
 @@ -575,7 +669,10 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
             // symlink, not the path that the symlink points to. We want the path
             // that the symlink points to, though, so we need to get the realpath.
             const pathname_w = try os.windows.wToPrefixedFileW(null, image_path_name);
-            return std.fs.cwd().realpathW(pathname_w.span(), out_buffer);
+            return std.fs.cwd().realpathW(pathname_w.span(), out_buffer) catch |err| switch (err) {
+                error.InvalidWtf8 => unreachable,
+                else => |e| return e,
+            };
         },
         else => @compileError("std.fs.selfExePath not supported for this target"),
     }
 @@ -599,6 +696,8 @@ pub fn selfExeDirPathAlloc(allocator: Allocator) ![]u8 {
 /// Get the directory path that contains the current executable.
 /// Returned value is a slice of out_buffer.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 pub fn selfExeDirPath(out_buffer: []u8) SelfExePathError![]const u8 {
     const self_exe_path = try selfExePath(out_buffer);
     // Assume that the OS APIs return absolute paths, and therefore dirname
 @@ -607,6 +706,8 @@ pub fn selfExeDirPath(out_buffer: []u8) SelfExePathError![]const u8 {
 }
 /// `realpath`, except caller must free the returned memory.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 /// See also `Dir.realpath`.
 pub fn realpathAlloc(allocator: Allocator, pathname: []const u8) ![]u8 {
     // Use of MAX_PATH_BYTES here is valid as the realpath function does not

lib/std/fs/Dir.zig+128-36

 @@ -9,7 +9,14 @@ pub const Entry = struct {
     pub const Kind = File.Kind;
 };
-const IteratorError = error{ AccessDenied, SystemResources } || posix.UnexpectedError;
+const IteratorError = error{
+    AccessDenied,
+    SystemResources,
+    /// WASI-only. The path of an entry could not be encoded as valid UTF-8.
+    /// WASI is unable to handle paths that cannot be encoded as well-formed UTF-8.
+    /// https://github.com/WebAssembly/wasi-filesystem/issues/17#issuecomment-1430639353
+    InvalidUtf8,
+} || posix.UnexpectedError;
 pub const Iterator = switch (builtin.os.tag) {
     .macos, .ios, .freebsd, .netbsd, .dragonfly, .openbsd, .solaris, .illumos => struct {
 @@ -445,13 +452,12 @@ pub const Iterator = switch (builtin.os.tag) {
                     self.index = self.buf.len;
                 }
-                const name_utf16le = @as([*]u16, @ptrCast(&dir_info.FileName))[0 .. dir_info.FileNameLength / 2];
+                const name_wtf16le = @as([*]u16, @ptrCast(&dir_info.FileName))[0 .. dir_info.FileNameLength / 2];
-                if (mem.eql(u16, name_utf16le, &[_]u16{'.'}) or mem.eql(u16, name_utf16le, &[_]u16{ '.', '.' }))
+                if (mem.eql(u16, name_wtf16le, &[_]u16{'.'}) or mem.eql(u16, name_wtf16le, &[_]u16{ '.', '.' }))
                     continue;
-                // Trust that Windows gives us valid UTF-16LE
+                const name_wtf8_len = std.unicode.wtf16LeToWtf8(self.name_data[0..], name_wtf16le);
-                const name_utf8_len = std.unicode.utf16LeToUtf8(self.name_data[0..], name_utf16le) catch unreachable;
+                const name_wtf8 = self.name_data[0..name_wtf8_len];
-                const name_utf8 = self.name_data[0..name_utf8_len];
                 const kind: Entry.Kind = blk: {
                     const attrs = dir_info.FileAttributes;
                     if (attrs & w.FILE_ATTRIBUTE_DIRECTORY != 0) break :blk .directory;
 @@ -459,7 +465,7 @@ pub const Iterator = switch (builtin.os.tag) {
                     break :blk .file;
                 };
                 return Entry{
-                    .name = name_utf8,
+                    .name = name_wtf8,
                     .kind = kind,
                 };
             }
 @@ -516,6 +522,7 @@ pub const Iterator = switch (builtin.os.tag) {
                         .INVAL => unreachable,
                         .NOENT => return error.DirNotFound, // The directory being iterated was deleted during iteration.
                         .NOTCAPABLE => return error.AccessDenied,
+                        .ILSEQ => return error.InvalidUtf8, // An entry's name cannot be encoded as UTF-8.
                         else => |err| return posix.unexpectedErrno(err),
                     }
                     if (bufused == 0) return null;
 @@ -743,7 +750,11 @@ pub const OpenError = error{
     SystemFdQuotaExceeded,
     NoDevice,
     SystemResources,
+    /// WASI-only; file paths must be valid UTF-8.
     InvalidUtf8,
+    /// Windows-only; file paths provided by the user must be valid WTF-8.
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
     BadPathName,
     DeviceBusy,
     /// On Windows, `\\server` or `\\server\share` was not found.
 @@ -759,6 +770,9 @@ pub fn close(self: *Dir) void {
 /// To create a new file, see `createFile`.
 /// Call `File.close` to release the resource.
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
     if (builtin.os.tag == .windows) {
         const path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);
 @@ -911,6 +925,9 @@ pub fn openFileW(self: Dir, sub_path_w: []const u16, flags: File.OpenFlags) File
 /// Creates, opens, or overwrites a file with write access.
 /// Call `File.close` on the result when done.
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
     if (builtin.os.tag == .windows) {
         const path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);
 @@ -1060,18 +1077,21 @@ pub fn createFileW(self: Dir, sub_path_w: []const u16, flags: File.CreateFlags)
 /// Creates a single directory with a relative or absolute path.
 /// To create multiple directories to make an entire path, see `makePath`.
 /// To operate on only absolute paths, see `makeDirAbsolute`.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn makeDir(self: Dir, sub_path: []const u8) !void {
     try posix.mkdirat(self.fd, sub_path, default_mode);
 }
-/// Creates a single directory with a relative or absolute null-terminated UTF-8-encoded path.
+/// Same as `makeDir`, but `sub_path` is null-terminated.
 /// To create multiple directories to make an entire path, see `makePath`.
 /// To operate on only absolute paths, see `makeDirAbsoluteZ`.
 pub fn makeDirZ(self: Dir, sub_path: [*:0]const u8) !void {
     try posix.mkdiratZ(self.fd, sub_path, default_mode);
 }
-/// Creates a single directory with a relative or absolute null-terminated WTF-16-encoded path.
+/// Creates a single directory with a relative or absolute null-terminated WTF-16 LE-encoded path.
 /// To create multiple directories to make an entire path, see `makePath`.
 /// To operate on only absolute paths, see `makeDirAbsoluteW`.
 pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) !void {
 @@ -1083,6 +1103,9 @@ pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) !void {
 /// Returns success if the path already exists and is a directory.
 /// This function is not atomic, and if it returns an error, the file system may
 /// have been modified regardless.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 ///
 /// Paths containing `..` components are handled differently depending on the platform:
 /// - On Windows, `..` are resolved before the path is passed to NtCreateFile, meaning
 @@ -1119,16 +1142,17 @@ pub fn makePath(self: Dir, sub_path: []const u8) !void {
     }
 }
-/// Calls makeOpenDirAccessMaskW iteratively to make an entire path
+/// Windows only. Calls makeOpenDirAccessMaskW iteratively to make an entire path
 /// (i.e. creating any parent directories that do not exist).
 /// Opens the dir if the path already exists and is a directory.
 /// This function is not atomic, and if it returns an error, the file system may
 /// have been modified regardless.
+/// `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
 fn makeOpenPathAccessMaskW(self: Dir, sub_path: []const u8, access_mask: u32, no_follow: bool) OpenError!Dir {
     const w = std.os.windows;
     var it = try fs.path.componentIterator(sub_path);
     // If there are no components in the path, then create a dummy component with the full path.
-    var component = it.last() orelse fs.path.NativeUtf8ComponentIterator.Component{
+    var component = it.last() orelse fs.path.NativeComponentIterator.Component{
         .name = "",
         .path = sub_path,
     };
 @@ -1156,7 +1180,9 @@ fn makeOpenPathAccessMaskW(self: Dir, sub_path: []const u8, access_mask: u32, no
 /// This function performs `makePath`, followed by `openDir`.
 /// If supported by the OS, this operation is atomic. It is not atomic on
 /// all operating systems.
-/// On Windows, this function performs `makeOpenPathAccessMaskW`.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn makeOpenPath(self: Dir, sub_path: []const u8, open_dir_options: OpenDirOptions) !Dir {
     return switch (builtin.os.tag) {
         .windows => {
 @@ -1185,6 +1211,10 @@ pub const RealPathError = posix.RealPathError;
 /// `pathname` relative to this `Dir`. If `pathname` is absolute, ignores this
 /// `Dir` handle and returns the canonicalized absolute pathname of `pathname`
 /// argument.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 /// This function is not universally supported by all platforms.
 /// Currently supported hosts are: Linux, macOS, and Windows.
 /// See also `Dir.realpathZ`, `Dir.realpathW`, and `Dir.realpathAlloc`.
 @@ -1224,6 +1254,7 @@ pub fn realpathZ(self: Dir, pathname: [*:0]const u8, out_buffer: []u8) RealPathE
         error.FileLocksNotSupported => return error.Unexpected,
         error.FileBusy => return error.Unexpected,
         error.WouldBlock => return error.Unexpected,
+        error.InvalidUtf8 => unreachable, // WASI-only
         else => |e| return e,
     };
     defer posix.close(fd);
 @@ -1246,7 +1277,8 @@ pub fn realpathZ(self: Dir, pathname: [*:0]const u8, out_buffer: []u8) RealPathE
     return result;
 }
-/// Windows-only. Same as `Dir.realpath` except `pathname` is WTF16 encoded.
+/// Windows-only. Same as `Dir.realpath` except `pathname` is WTF16 LE encoded.
+/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
 /// See also `Dir.realpath`, `realpathW`.
 pub fn realpathW(self: Dir, pathname: []const u16, out_buffer: []u8) RealPathError![]u8 {
     const w = std.os.windows;
 @@ -1272,16 +1304,7 @@ pub fn realpathW(self: Dir, pathname: []const u16, out_buffer: []u8) RealPathErr
     var wide_buf: [w.PATH_MAX_WIDE]u16 = undefined;
     const wide_slice = try w.GetFinalPathNameByHandle(h_file, .{}, &wide_buf);
     var big_out_buf: [fs.MAX_PATH_BYTES]u8 = undefined;
-    const end_index = std.unicode.utf16leToUtf8(&big_out_buf, wide_slice) catch |e| switch (e) {
+    const end_index = std.unicode.wtf16LeToWtf8(&big_out_buf, wide_slice);
-        // TODO: Windows file paths can be arbitrary arrays of u16 values and
-        // must not fail with InvalidUtf8.
-        error.DanglingSurrogateHalf,
-        error.ExpectedSecondSurrogateHalf,
-        error.UnexpectedSecondSurrogateHalf,
-        error.CodepointTooLarge,
-        error.Utf8CannotEncodeSurrogateHalf,
-        => return error.InvalidUtf8,
-    };
     if (end_index > out_buffer.len)
         return error.NameTooLong;
     const result = out_buffer[0..end_index];
 @@ -1344,6 +1367,9 @@ pub const OpenDirOptions = struct {
 /// open until `close` is called on the result.
 /// The directory cannot be iterated unless the `iterate` option is set to `true`.
 ///
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 /// Asserts that the path parameter has no null bytes.
 pub fn openDir(self: Dir, sub_path: []const u8, args: OpenDirOptions) OpenError!Dir {
     switch (builtin.os.tag) {
 @@ -1428,7 +1454,7 @@ pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenDirOptions) Open
     }
 }
-/// Same as `openDir` except the path parameter is WTF-16 encoded, NT-prefixed.
+/// Same as `openDir` except the path parameter is WTF-16 LE encoded, NT-prefixed.
 /// This function asserts the target OS is Windows.
 pub fn openDirW(self: Dir, sub_path_w: [*:0]const u16, args: OpenDirOptions) OpenError!Dir {
     const w = std.os.windows;
 @@ -1518,6 +1544,9 @@ fn makeOpenDirAccessMaskW(self: Dir, sub_path_w: [*:0]const u16, access_mask: u3
 pub const DeleteFileError = posix.UnlinkError;
 /// Delete a file name and possibly the file it refers to, based on an open directory handle.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 /// Asserts that the path parameter has no null bytes.
 pub fn deleteFile(self: Dir, sub_path: []const u8) DeleteFileError!void {
     if (builtin.os.tag == .windows) {
 @@ -1553,7 +1582,7 @@ pub fn deleteFileZ(self: Dir, sub_path_c: [*:0]const u8) DeleteFileError!void {
     };
 }
-/// Same as `deleteFile` except the parameter is WTF-16 encoded.
+/// Same as `deleteFile` except the parameter is WTF-16 LE encoded.
 pub fn deleteFileW(self: Dir, sub_path_w: []const u16) DeleteFileError!void {
     posix.unlinkatW(self.fd, sub_path_w, 0) catch |err| switch (err) {
         error.DirNotEmpty => unreachable, // not passing AT.REMOVEDIR
 @@ -1572,7 +1601,11 @@ pub const DeleteDirError = error{
     NotDir,
     SystemResources,
     ReadOnlyFileSystem,
+    /// WASI-only; file paths must be valid UTF-8.
     InvalidUtf8,
+    /// Windows-only; file paths provided by the user must be valid WTF-8.
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
     BadPathName,
     /// On Windows, `\\server` or `\\server\share` was not found.
     NetworkNotFound,
 @@ -1581,6 +1614,9 @@ pub const DeleteDirError = error{
 /// Returns `error.DirNotEmpty` if the directory is not empty.
 /// To delete a directory recursively, see `deleteTree`.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 /// Asserts that the path parameter has no null bytes.
 pub fn deleteDir(self: Dir, sub_path: []const u8) DeleteDirError!void {
     if (builtin.os.tag == .windows) {
 @@ -1605,7 +1641,7 @@ pub fn deleteDirZ(self: Dir, sub_path_c: [*:0]const u8) DeleteDirError!void {
     };
 }
-/// Same as `deleteDir` except the parameter is UTF16LE, NT prefixed.
+/// Same as `deleteDir` except the parameter is WTF16LE, NT prefixed.
 /// This function is Windows-only.
 pub fn deleteDirW(self: Dir, sub_path_w: []const u16) DeleteDirError!void {
     posix.unlinkatW(self.fd, sub_path_w, posix.AT.REMOVEDIR) catch |err| switch (err) {
 @@ -1620,6 +1656,9 @@ pub const RenameError = posix.RenameError;
 /// If new_sub_path already exists, it will be replaced.
 /// Renaming a file over an existing directory or a directory
 /// over an existing file will fail with `error.IsDir` or `error.NotDir`
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn rename(self: Dir, old_sub_path: []const u8, new_sub_path: []const u8) RenameError!void {
     return posix.renameat(self.fd, old_sub_path, self.fd, new_sub_path);
 }
 @@ -1629,7 +1668,7 @@ pub fn renameZ(self: Dir, old_sub_path_z: [*:0]const u8, new_sub_path_z: [*:0]co
     return posix.renameatZ(self.fd, old_sub_path_z, self.fd, new_sub_path_z);
 }
-/// Same as `rename` except the parameters are UTF16LE, NT prefixed.
+/// Same as `rename` except the parameters are WTF16LE, NT prefixed.
 /// This function is Windows-only.
 pub fn renameW(self: Dir, old_sub_path_w: []const u16, new_sub_path_w: []const u16) RenameError!void {
     return posix.renameatW(self.fd, old_sub_path_w, self.fd, new_sub_path_w);
 @@ -1647,6 +1686,9 @@ pub const SymLinkFlags = struct {
 /// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent
 /// one; the latter case is known as a dangling link.
 /// If `sym_link_path` exists, it will not be overwritten.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn symLink(
     self: Dir,
     target_path: []const u8,
 @@ -1662,7 +1704,7 @@ pub fn symLink(
         // when converting to an NT namespaced path. CreateSymbolicLink in
         // symLinkW will handle the necessary conversion.
         var target_path_w: std.os.windows.PathSpace = undefined;
-        target_path_w.len = try std.unicode.utf8ToUtf16Le(&target_path_w.data, target_path);
+        target_path_w.len = try std.unicode.wtf8ToWtf16Le(&target_path_w.data, target_path);
         target_path_w.data[target_path_w.len] = 0;
         const sym_link_path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sym_link_path);
         return self.symLinkW(target_path_w.span(), sym_link_path_w.span(), flags);
 @@ -1698,7 +1740,7 @@ pub fn symLinkZ(
 }
 /// Windows-only. Same as `symLink` except the pathname parameters
-/// are null-terminated, WTF16 encoded.
+/// are WTF16 LE encoded.
 pub fn symLinkW(
     self: Dir,
     /// WTF-16, does not need to be NT-prefixed. The NT-prefixing
 @@ -1716,6 +1758,9 @@ pub const ReadLinkError = posix.ReadLinkError;
 /// Read value of a symbolic link.
 /// The return value is a slice of `buffer`, from index `0`.
 /// Asserts that the path parameter has no null bytes.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn readLink(self: Dir, sub_path: []const u8, buffer: []u8) ReadLinkError![]u8 {
     if (builtin.os.tag == .wasi and !builtin.link_libc) {
         return self.readLinkWasi(sub_path, buffer);
 @@ -1733,7 +1778,7 @@ pub fn readLinkWasi(self: Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
     return posix.readlinkat(self.fd, sub_path, buffer);
 }
-/// Same as `readLink`, except the `pathname` parameter is null-terminated.
+/// Same as `readLink`, except the `sub_path_c` parameter is null-terminated.
 pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: []u8) ![]u8 {
     if (builtin.os.tag == .windows) {
         const sub_path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);
 @@ -1743,7 +1788,7 @@ pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: []u8) ![]u8 {
 }
 /// Windows-only. Same as `readLink` except the pathname parameter
-/// is null-terminated, WTF16 encoded.
+/// is WTF16 LE encoded.
 pub fn readLinkW(self: Dir, sub_path_w: []const u16, buffer: []u8) ![]u8 {
     return std.os.windows.ReadLink(self.fd, sub_path_w, buffer);
 }
 @@ -1753,6 +1798,9 @@ pub fn readLinkW(self: Dir, sub_path_w: []const u16, buffer: []u8) ![]u8 {
 /// the situation is ambiguous. It could either mean that the entire file was read, and
 /// it exactly fits the buffer, or it could mean the buffer was not big enough for the
 /// entire file.
+/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `file_path` should be encoded as valid UTF-8.
+/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
 pub fn readFile(self: Dir, file_path: []const u8, buffer: []u8) ![]u8 {
     var file = try self.openFile(file_path, .{});
     defer file.close();
 @@ -1763,6 +1811,9 @@ pub fn readFile(self: Dir, file_path: []const u8, buffer: []u8) ![]u8 {
 /// On success, caller owns returned buffer.
 /// If the file is larger than `max_bytes`, returns `error.FileTooBig`.
+/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `file_path` should be encoded as valid UTF-8.
+/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
 pub fn readFileAlloc(self: Dir, allocator: mem.Allocator, file_path: []const u8, max_bytes: usize) ![]u8 {
     return self.readFileAllocOptions(allocator, file_path, max_bytes, null, @alignOf(u8), null);
 }
 @@ -1772,6 +1823,9 @@ pub fn readFileAlloc(self: Dir, allocator: mem.Allocator, file_path: []const u8,
 /// If `size_hint` is specified the initial buffer size is calculated using
 /// that value, otherwise the effective file size is used instead.
 /// Allows specifying alignment and a sentinel value.
+/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `file_path` should be encoded as valid UTF-8.
+/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
 pub fn readFileAllocOptions(
     self: Dir,
     allocator: mem.Allocator,
 @@ -1811,9 +1865,13 @@ pub const DeleteTreeError = error{
     /// This error is unreachable if `sub_path` does not contain a path separator.
     NotDir,
-    /// On Windows, file paths must be valid Unicode.
+    /// WASI-only; file paths must be valid UTF-8.
     InvalidUtf8,
+    /// Windows-only; file paths provided by the user must be valid WTF-8.
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
     /// On Windows, file paths cannot contain these characters:
     /// '/', '*', '?', '"', '<', '>', '|'
     BadPathName,
 @@ -1826,6 +1884,9 @@ pub const DeleteTreeError = error{
 /// removes it. If it cannot be removed because it is a non-empty directory,
 /// this function recursively removes its entries and then tries again.
 /// This operation is not atomic on most file systems.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
     var initial_iterable_dir = (try self.deleteTreeOpenInitialSubpath(sub_path, .file)) orelse return;
 @@ -1879,6 +1940,7 @@ pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
                             error.SystemResources,
                             error.Unexpected,
                             error.InvalidUtf8,
+                            error.InvalidWtf8,
                             error.BadPathName,
                             error.NetworkNotFound,
                             error.DeviceBusy,
 @@ -1910,6 +1972,7 @@ pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
                         error.AccessDenied,
                         error.InvalidUtf8,
+                        error.InvalidWtf8,
                         error.SymLinkLoop,
                         error.NameTooLong,
                         error.SystemResources,
 @@ -1973,6 +2036,7 @@ pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
                             error.SystemResources,
                             error.Unexpected,
                             error.InvalidUtf8,
+                            error.InvalidWtf8,
                             error.BadPathName,
                             error.NetworkNotFound,
                             error.DeviceBusy,
 @@ -1994,6 +2058,7 @@ pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
                             error.AccessDenied,
                             error.InvalidUtf8,
+                            error.InvalidWtf8,
                             error.SymLinkLoop,
                             error.NameTooLong,
                             error.SystemResources,
 @@ -2022,6 +2087,9 @@ pub fn deleteTree(self: Dir, sub_path: []const u8) DeleteTreeError!void {
 /// Like `deleteTree`, but only keeps one `Iterator` active at a time to minimize the function's stack size.
 /// This is slower than `deleteTree` but uses less stack space.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn deleteTreeMinStackSize(self: Dir, sub_path: []const u8) DeleteTreeError!void {
     return self.deleteTreeMinStackSizeWithKindHint(sub_path, .file);
 }
 @@ -2074,6 +2142,7 @@ fn deleteTreeMinStackSizeWithKindHint(self: Dir, sub_path: []const u8, kind_hint
                             error.SystemResources,
                             error.Unexpected,
                             error.InvalidUtf8,
+                            error.InvalidWtf8,
                             error.BadPathName,
                             error.NetworkNotFound,
                             error.DeviceBusy,
 @@ -2102,6 +2171,7 @@ fn deleteTreeMinStackSizeWithKindHint(self: Dir, sub_path: []const u8, kind_hint
                             error.AccessDenied,
                             error.InvalidUtf8,
+                            error.InvalidWtf8,
                             error.SymLinkLoop,
                             error.NameTooLong,
                             error.SystemResources,
 @@ -2171,6 +2241,7 @@ fn deleteTreeOpenInitialSubpath(self: Dir, sub_path: []const u8, kind_hint: File
                     error.SystemResources,
                     error.Unexpected,
                     error.InvalidUtf8,
+                    error.InvalidWtf8,
                     error.BadPathName,
                     error.DeviceBusy,
                     error.NetworkNotFound,
 @@ -2189,6 +2260,7 @@ fn deleteTreeOpenInitialSubpath(self: Dir, sub_path: []const u8, kind_hint: File
                     error.AccessDenied,
                     error.InvalidUtf8,
+                    error.InvalidWtf8,
                     error.SymLinkLoop,
                     error.NameTooLong,
                     error.SystemResources,
 @@ -2209,6 +2281,9 @@ fn deleteTreeOpenInitialSubpath(self: Dir, sub_path: []const u8, kind_hint: File
 pub const WriteFileError = File.WriteError || File.OpenError;
 /// Deprecated: use `writeFile2`.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn writeFile(self: Dir, sub_path: []const u8, data: []const u8) WriteFileError!void {
     return writeFile2(self, .{
         .sub_path = sub_path,
 @@ -2218,6 +2293,9 @@ pub fn writeFile(self: Dir, sub_path: []const u8, data: []const u8) WriteFileErr
 }
 pub const WriteFileOptions = struct {
+    /// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+    /// On WASI, `sub_path` should be encoded as valid UTF-8.
+    /// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
     sub_path: []const u8,
     data: []const u8,
     flags: File.CreateFlags = .{},
 @@ -2232,8 +2310,10 @@ pub fn writeFile2(self: Dir, options: WriteFileOptions) WriteFileError!void {
 pub const AccessError = posix.AccessError;
-/// Test accessing `path`.
+/// Test accessing `sub_path`.
-/// `path` is UTF-8-encoded.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 /// Be careful of Time-Of-Check-Time-Of-Use race conditions when using this function.
 /// For example, instead of testing if a file exists and then opening it, just
 /// open it and handle the error for file not found.
 @@ -2268,9 +2348,9 @@ pub fn accessZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) Access
 }
 /// Same as `access` except asserts the target OS is Windows and the path parameter is
-/// * WTF-16 encoded
+/// * WTF-16 LE encoded
 /// * null-terminated
-/// * NtDll prefixed
+/// * relative or has the NT namespace prefix
 /// TODO currently this ignores `flags`.
 pub fn accessW(self: Dir, sub_path_w: [*:0]const u16, flags: File.OpenFlags) AccessError!void {
     _ = flags;
 @@ -2292,6 +2372,9 @@ pub const PrevStatus = enum {
 /// atime, and mode of the source file so that the next call to `updateFile` will not need a copy.
 /// Returns the previous status of the file before updating.
 /// If any of the directories do not exist for dest_path, they are created.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn updateFile(
     source_dir: Dir,
     source_path: []const u8,
 @@ -2343,6 +2426,9 @@ pub const CopyFileError = File.OpenError || File.StatError ||
 /// On Linux, until https://patchwork.kernel.org/patch/9636735/ is merged and readily available,
 /// there is a possibility of power loss or application termination leaving temporary files present
 /// in the same directory as dest_path.
+/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, both paths should be encoded as valid UTF-8.
+/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
 pub fn copyFile(
     source_dir: Dir,
     source_path: []const u8,
 @@ -2430,6 +2516,9 @@ pub const AtomicFileOptions = struct {
 /// Always call `AtomicFile.deinit` to clean up, regardless of whether
 /// `AtomicFile.finish` succeeded. `dest_path` must remain valid until
 /// `AtomicFile.deinit` is called.
+/// On Windows, `dest_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `dest_path` should be encoded as valid UTF-8.
+/// On other platforms, `dest_path` is an opaque sequence of bytes with no particular encoding.
 pub fn atomicFile(self: Dir, dest_path: []const u8, options: AtomicFileOptions) !AtomicFile {
     if (fs.path.dirname(dest_path)) |dirname| {
         const dir = if (options.make_path)
 @@ -2461,6 +2550,9 @@ pub const StatFileError = File.OpenError || File.StatError || posix.FStatAtError
 /// Symlinks are followed.
 ///
 /// `sub_path` may be absolute, in which case `self` is ignored.
+/// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On WASI, `sub_path` should be encoded as valid UTF-8.
+/// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
 pub fn statFile(self: Dir, sub_path: []const u8) StatFileError!Stat {
     if (builtin.os.tag == .windows) {
         var file = try self.openFile(sub_path, .{});

lib/std/fs/File.zig+4-1

 @@ -40,8 +40,11 @@ pub const OpenError = error{
     AccessDenied,
     PipeBusy,
     NameTooLong,
-    /// On Windows, file paths must be valid Unicode.
+    /// WASI-only; file paths must be valid UTF-8.
     InvalidUtf8,
+    /// Windows-only; file paths provided by the user must be valid WTF-8.
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
     /// On Windows, file paths cannot contain these characters:
     /// '/', '*', '?', '"', '<', '>', '|'
     BadPathName,

lib/std/fs/path.zig+21-7

 @@ -1,3 +1,17 @@
+//! POSIX paths are arbitrary sequences of `u8` with no particular encoding.
+//!
+//! Windows paths are arbitrary sequences of `u16` (WTF-16).
+//! For cross-platform APIs that deal with sequences of `u8`, Windows
+//! paths are encoded by Zig as [WTF-8](https://simonsapin.github.io/wtf-8/).
+//! WTF-8 is a superset of UTF-8 that allows encoding surrogate codepoints,
+//! which enables lossless roundtripping when converting to/from WTF-16
+//! (as long as the WTF-8 encoded surrogate codepoints do not form a pair).
+//!
+//! WASI paths are sequences of valid Unicode scalar values,
+//! which means that WASI is unable to handle paths that cannot be
+//! encoded as well-formed UTF-8/UTF-16.
+//! https://github.com/WebAssembly/wasi-filesystem/issues/17#issuecomment-1430639353
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 const debug = std.debug;
 @@ -438,7 +452,7 @@ fn networkShareServersEql(ns1: []const u8, ns2: []const u8) bool {
     var it1 = mem.tokenizeScalar(u8, ns1, sep1);
     var it2 = mem.tokenizeScalar(u8, ns2, sep2);
-    return windows.eqlIgnoreCaseUtf8(it1.next().?, it2.next().?);
+    return windows.eqlIgnoreCaseWtf8(it1.next().?, it2.next().?);
 }
 fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8) bool {
 @@ -458,7 +472,7 @@ fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8
             var it1 = mem.tokenizeScalar(u8, p1, sep1);
             var it2 = mem.tokenizeScalar(u8, p2, sep2);
-            return windows.eqlIgnoreCaseUtf8(it1.next().?, it2.next().?) and windows.eqlIgnoreCaseUtf8(it1.next().?, it2.next().?);
+            return windows.eqlIgnoreCaseWtf8(it1.next().?, it2.next().?) and windows.eqlIgnoreCaseWtf8(it1.next().?, it2.next().?);
         },
     }
 }
 @@ -1099,7 +1113,7 @@ pub fn relativeWindows(allocator: Allocator, from: []const u8, to: []const u8) !
         const from_component = from_it.next() orelse return allocator.dupe(u8, to_it.rest());
         const to_rest = to_it.rest();
         if (to_it.next()) |to_component| {
-            if (windows.eqlIgnoreCaseUtf8(from_component, to_component))
+            if (windows.eqlIgnoreCaseWtf8(from_component, to_component))
                 continue;
         }
         var up_index_end = "..".len;
 @@ -1564,14 +1578,14 @@ pub fn ComponentIterator(comptime path_type: PathType, comptime T: type) type {
     };
 }
-pub const NativeUtf8ComponentIterator = ComponentIterator(switch (native_os) {
+pub const NativeComponentIterator = ComponentIterator(switch (native_os) {
     .windows => .windows,
     .uefi => .uefi,
     else => .posix,
 }, u8);
-pub fn componentIterator(path: []const u8) !NativeUtf8ComponentIterator {
+pub fn componentIterator(path: []const u8) !NativeComponentIterator {
-    return NativeUtf8ComponentIterator.init(path);
+    return NativeComponentIterator.init(path);
 }
 test "ComponentIterator posix" {
 @@ -1826,7 +1840,7 @@ test "ComponentIterator windows" {
     }
 }
-test "ComponentIterator windows UTF-16" {
+test "ComponentIterator windows WTF-16" {
     // TODO: Fix on big endian architectures
     if (builtin.cpu.arch.endian() != .little) {
         return error.SkipZigTest;

lib/std/fs/test.zig+126-8

...	@@ -26,39 +26,39 @@ const PathType = enum {	...	@@ -26,39 +26,39 @@ const PathType = enum {
26	}	26	}
27		27
28	pub const TransformError = std.os.RealPathError \|\| error{OutOfMemory};	28	pub const TransformError = std.os.RealPathError \|\| error{OutOfMemory};
29	pub const TransformFn = fn (allocator: mem.Allocator, dir: Dir, relative_path: []const u8) TransformError![]const u8;	29	pub const TransformFn = fn (allocator: mem.Allocator, dir: Dir, relative_path: [:0]const u8) TransformError![:0]const u8;
30		30
31	pub fn getTransformFn(comptime path_type: PathType) TransformFn {	31	pub fn getTransformFn(comptime path_type: PathType) TransformFn {
32	switch (path_type) {	32	switch (path_type) {
33	.relative => return struct {	33	.relative => return struct {
34	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: []const u8) TransformError![]const u8 {	34	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: [:0]const u8) TransformError![:0]const u8 {
35	_ = allocator;	35	_ = allocator;
36	_ = dir;	36	_ = dir;
37	return relative_path;	37	return relative_path;
38	}	38	}
39	}.transform,	39	}.transform,
40	.absolute => return struct {	40	.absolute => return struct {
41	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: []const u8) TransformError![]const u8 {	41	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: [:0]const u8) TransformError![:0]const u8 {
42	// The final path may not actually exist which would cause realpath to fail.	42	// The final path may not actually exist which would cause realpath to fail.
43	// So instead, we get the path of the dir and join it with the relative path.	43	// So instead, we get the path of the dir and join it with the relative path.
44	var fd_path_buf: [fs.MAX_PATH_BYTES]u8 = undefined;	44	var fd_path_buf: [fs.MAX_PATH_BYTES]u8 = undefined;
45	const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);	45	const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);
46	return fs.path.join(allocator, &.{ dir_path, relative_path });	46	return fs.path.joinZ(allocator, &.{ dir_path, relative_path });
47	}	47	}
48	}.transform,	48	}.transform,
49	.unc => return struct {	49	.unc => return struct {
50	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: []const u8) TransformError![]const u8 {	50	fn transform(allocator: mem.Allocator, dir: Dir, relative_path: [:0]const u8) TransformError![:0]const u8 {
51	// Any drive absolute path (C:\foo) can be converted into a UNC path by	51	// Any drive absolute path (C:\foo) can be converted into a UNC path by
52	// using '127.0.0.1' as the server name and '<drive letter>$' as the share name.	52	// using '127.0.0.1' as the server name and '<drive letter>$' as the share name.
53	var fd_path_buf: [fs.MAX_PATH_BYTES]u8 = undefined;	53	var fd_path_buf: [fs.MAX_PATH_BYTES]u8 = undefined;
54	const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);	54	const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);
55	const windows_path_type = std.os.windows.getUnprefixedPathType(u8, dir_path);	55	const windows_path_type = std.os.windows.getUnprefixedPathType(u8, dir_path);
56	switch (windows_path_type) {	56	switch (windows_path_type) {
57	.unc_absolute => return fs.path.join(allocator, &.{ dir_path, relative_path }),	57	.unc_absolute => return fs.path.joinZ(allocator, &.{ dir_path, relative_path }),
58	.drive_absolute => {	58	.drive_absolute => {
59	// `C:\<...>` -> `\\127.0.0.1\C$\<...>`	59	// `C:\<...>` -> `\\127.0.0.1\C$\<...>`
60	const prepended = "\\\\127.0.0.1\\";	60	const prepended = "\\\\127.0.0.1\\";
61	var path = try fs.path.join(allocator, &.{ prepended, dir_path, relative_path });	61	var path = try fs.path.joinZ(allocator, &.{ prepended, dir_path, relative_path });
62	path[prepended.len + 1] = '$';	62	path[prepended.len + 1] = '$';
63	return path;	63	return path;
64	},	64	},
...	@@ -96,7 +96,7 @@ const TestContext = struct {	...	@@ -96,7 +96,7 @@ const TestContext = struct {
96	/// Returns the `relative_path` transformed into the TestContext's `path_type`.	96	/// Returns the `relative_path` transformed into the TestContext's `path_type`.
97	/// The result is allocated by the TestContext's arena and will be free'd during	97	/// The result is allocated by the TestContext's arena and will be free'd during
98	/// `TestContext.deinit`.	98	/// `TestContext.deinit`.
99	pub fn transformPath(self: *TestContext, relative_path: []const u8) ![]const u8 {	99	pub fn transformPath(self: *TestContext, relative_path: [:0]const u8) ![:0]const u8 {
100	return self.transform_fn(self.arena.allocator(), self.dir, relative_path);	100	return self.transform_fn(self.arena.allocator(), self.dir, relative_path);
101	}	101	}
102	};	102	};
...	@@ -1001,6 +1001,16 @@ test "openSelfExe" {	...	@@ -1001,6 +1001,16 @@ test "openSelfExe" {
1001	self_exe_file.close();	1001	self_exe_file.close();
1002	}	1002	}
1003		1003
		1004	test "selfExePath" {
		1005	if (builtin.os.tag == .wasi) return error.SkipZigTest;
		1006
		1007	var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
		1008	const buf_self_exe_path = try std.fs.selfExePath(&buf);
		1009	const alloc_self_exe_path = try std.fs.selfExePathAlloc(testing.allocator);
		1010	defer testing.allocator.free(alloc_self_exe_path);
		1011	try testing.expectEqualSlices(u8, buf_self_exe_path, alloc_self_exe_path);
		1012	}
		1013
1004	test "deleteTree does not follow symlinks" {	1014	test "deleteTree does not follow symlinks" {
1005	var tmp = tmpDir(.{});	1015	var tmp = tmpDir(.{});
1006	defer tmp.cleanup();	1016	defer tmp.cleanup();
...	@@ -1907,3 +1917,111 @@ test "delete a setAsCwd directory on Windows" {	...	@@ -1907,3 +1917,111 @@ test "delete a setAsCwd directory on Windows" {
1907	// Close the parent "tmp" so we don't leak the HANDLE.	1917	// Close the parent "tmp" so we don't leak the HANDLE.
1908	tmp.parent_dir.close();	1918	tmp.parent_dir.close();
1909	}	1919	}
		1920
		1921	test "invalid UTF-8/WTF-8 paths" {
		1922	const expected_err = switch (builtin.os.tag) {
		1923	.wasi => error.InvalidUtf8,
		1924	.windows => error.InvalidWtf8,
		1925	else => return error.SkipZigTest,
		1926	};
		1927
		1928	try testWithAllSupportedPathTypes(struct {
		1929	fn impl(ctx: *TestContext) !void {
		1930	// This is both invalid UTF-8 and WTF-8, since \xFF is an invalid start byte
		1931	const invalid_path = try ctx.transformPath("\xFF");
		1932
		1933	try testing.expectError(expected_err, ctx.dir.openFile(invalid_path, .{}));
		1934	try testing.expectError(expected_err, ctx.dir.openFileZ(invalid_path, .{}));
		1935
		1936	try testing.expectError(expected_err, ctx.dir.createFile(invalid_path, .{}));
		1937	try testing.expectError(expected_err, ctx.dir.createFileZ(invalid_path, .{}));
		1938
		1939	try testing.expectError(expected_err, ctx.dir.makeDir(invalid_path));
		1940	try testing.expectError(expected_err, ctx.dir.makeDirZ(invalid_path));
		1941
		1942	try testing.expectError(expected_err, ctx.dir.makePath(invalid_path));
		1943	try testing.expectError(expected_err, ctx.dir.makeOpenPath(invalid_path, .{}));
		1944
		1945	try testing.expectError(expected_err, ctx.dir.openDir(invalid_path, .{}));
		1946	try testing.expectError(expected_err, ctx.dir.openDirZ(invalid_path, .{}));
		1947
		1948	try testing.expectError(expected_err, ctx.dir.deleteFile(invalid_path));
		1949	try testing.expectError(expected_err, ctx.dir.deleteFileZ(invalid_path));
		1950
		1951	try testing.expectError(expected_err, ctx.dir.deleteDir(invalid_path));
		1952	try testing.expectError(expected_err, ctx.dir.deleteDirZ(invalid_path));
		1953
		1954	try testing.expectError(expected_err, ctx.dir.rename(invalid_path, invalid_path));
		1955	try testing.expectError(expected_err, ctx.dir.renameZ(invalid_path, invalid_path));
		1956
		1957	try testing.expectError(expected_err, ctx.dir.symLink(invalid_path, invalid_path, .{}));
		1958	try testing.expectError(expected_err, ctx.dir.symLinkZ(invalid_path, invalid_path, .{}));
		1959	if (builtin.os.tag == .wasi) {
		1960	try testing.expectError(expected_err, ctx.dir.symLinkWasi(invalid_path, invalid_path, .{}));
		1961	}
		1962
		1963	try testing.expectError(expected_err, ctx.dir.readLink(invalid_path, &[_]u8{}));
		1964	try testing.expectError(expected_err, ctx.dir.readLinkZ(invalid_path, &[_]u8{}));
		1965	if (builtin.os.tag == .wasi) {
		1966	try testing.expectError(expected_err, ctx.dir.readLinkWasi(invalid_path, &[_]u8{}));
		1967	}
		1968
		1969	try testing.expectError(expected_err, ctx.dir.readFile(invalid_path, &[_]u8{}));
		1970	try testing.expectError(expected_err, ctx.dir.readFileAlloc(testing.allocator, invalid_path, 0));
		1971
		1972	try testing.expectError(expected_err, ctx.dir.deleteTree(invalid_path));
		1973	try testing.expectError(expected_err, ctx.dir.deleteTreeMinStackSize(invalid_path));
		1974
		1975	try testing.expectError(expected_err, ctx.dir.writeFile(invalid_path, ""));
		1976	try testing.expectError(expected_err, ctx.dir.writeFile2(.{
		1977	.sub_path = invalid_path,
		1978	.data = "",
		1979	}));
		1980
		1981	try testing.expectError(expected_err, ctx.dir.access(invalid_path, .{}));
		1982	try testing.expectError(expected_err, ctx.dir.accessZ(invalid_path, .{}));
		1983
		1984	try testing.expectError(expected_err, ctx.dir.updateFile(invalid_path, ctx.dir, invalid_path, .{}));
		1985	try testing.expectError(expected_err, ctx.dir.copyFile(invalid_path, ctx.dir, invalid_path, .{}));
		1986
		1987	try testing.expectError(expected_err, ctx.dir.statFile(invalid_path));
		1988
		1989	if (builtin.os.tag != .wasi) {
		1990	try testing.expectError(expected_err, ctx.dir.realpath(invalid_path, &[_]u8{}));
		1991	try testing.expectError(expected_err, ctx.dir.realpathZ(invalid_path, &[_]u8{}));
		1992	try testing.expectError(expected_err, ctx.dir.realpathAlloc(testing.allocator, invalid_path));
		1993	}
		1994
		1995	try testing.expectError(expected_err, fs.rename(ctx.dir, invalid_path, ctx.dir, invalid_path));
		1996	try testing.expectError(expected_err, fs.renameZ(ctx.dir, invalid_path, ctx.dir, invalid_path));
		1997
		1998	if (builtin.os.tag != .wasi and ctx.path_type != .relative) {
		1999	try testing.expectError(expected_err, fs.updateFileAbsolute(invalid_path, invalid_path, .{}));
		2000	try testing.expectError(expected_err, fs.copyFileAbsolute(invalid_path, invalid_path, .{}));
		2001	try testing.expectError(expected_err, fs.makeDirAbsolute(invalid_path));
		2002	try testing.expectError(expected_err, fs.makeDirAbsoluteZ(invalid_path));
		2003	try testing.expectError(expected_err, fs.deleteDirAbsolute(invalid_path));
		2004	try testing.expectError(expected_err, fs.deleteDirAbsoluteZ(invalid_path));
		2005	try testing.expectError(expected_err, fs.renameAbsolute(invalid_path, invalid_path));
		2006	try testing.expectError(expected_err, fs.renameAbsoluteZ(invalid_path, invalid_path));
		2007	try testing.expectError(expected_err, fs.openDirAbsolute(invalid_path, .{}));
		2008	try testing.expectError(expected_err, fs.openDirAbsoluteZ(invalid_path, .{}));
		2009	try testing.expectError(expected_err, fs.openFileAbsolute(invalid_path, .{}));
		2010	try testing.expectError(expected_err, fs.openFileAbsoluteZ(invalid_path, .{}));
		2011	try testing.expectError(expected_err, fs.accessAbsolute(invalid_path, .{}));
		2012	try testing.expectError(expected_err, fs.accessAbsoluteZ(invalid_path, .{}));
		2013	try testing.expectError(expected_err, fs.createFileAbsolute(invalid_path, .{}));
		2014	try testing.expectError(expected_err, fs.createFileAbsoluteZ(invalid_path, .{}));
		2015	try testing.expectError(expected_err, fs.deleteFileAbsolute(invalid_path));
		2016	try testing.expectError(expected_err, fs.deleteFileAbsoluteZ(invalid_path));
		2017	try testing.expectError(expected_err, fs.deleteTreeAbsolute(invalid_path));
		2018	var readlink_buf: [fs.MAX_PATH_BYTES]u8 = undefined;
		2019	try testing.expectError(expected_err, fs.readLinkAbsolute(invalid_path, &readlink_buf));
		2020	try testing.expectError(expected_err, fs.readLinkAbsoluteZ(invalid_path, &readlink_buf));
		2021	try testing.expectError(expected_err, fs.symLinkAbsolute(invalid_path, invalid_path, .{}));
		2022	try testing.expectError(expected_err, fs.symLinkAbsoluteZ(invalid_path, invalid_path, .{}));
		2023	try testing.expectError(expected_err, fs.realpathAlloc(testing.allocator, invalid_path));
		2024	}
		2025	}
		2026	}.impl);
		2027	}

lib/std/fs/watch.zig deleted-719

...	@@ -1,719 +0,0 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3	const event = std.event;
4	const assert = std.debug.assert;
5	const testing = std.testing;
6	const os = std.os;
7	const mem = std.mem;
8	const windows = os.windows;
9	const Loop = event.Loop;
10	const fd_t = os.fd_t;
11	const File = std.fs.File;
12	const Allocator = mem.Allocator;
13
14	const global_event_loop = Loop.instance orelse
15	@compileError("std.fs.Watch currently only works with event-based I/O");
16
17	const WatchEventId = enum {
18	CloseWrite,
19	Delete,
20	};
21
22	const WatchEventError = error{
23	UserResourceLimitReached,
24	SystemResources,
25	AccessDenied,
26	Unexpected, // TODO remove this possibility
27	};
28
29	pub fn Watch(comptime V: type) type {
30	return struct {
31	channel: event.Channel(Event.Error!Event),
32	os_data: OsData,
33	allocator: Allocator,
34
35	const OsData = switch (builtin.os.tag) {
36	// TODO https://github.com/ziglang/zig/issues/3778
37	.macos, .freebsd, .netbsd, .dragonfly, .openbsd => KqOsData,
38	.linux => LinuxOsData,
39	.windows => WindowsOsData,
40
41	else => @compileError("Unsupported OS"),
42	};
43
44	const KqOsData = struct {
45	table_lock: event.Lock,
46	file_table: FileTable,
47
48	const FileTable = std.StringHashMapUnmanaged(*Put);
49	const Put = struct {
50	putter_frame: @Frame(kqPutEvents),
51	cancelled: bool = false,
52	value: V,
53	};
54	};
55
56	const WindowsOsData = struct {
57	table_lock: event.Lock,
58	dir_table: DirTable,
59	cancelled: bool = false,
60
61	const DirTable = std.StringHashMapUnmanaged(*Dir);
62	const FileTable = std.StringHashMapUnmanaged(V);
63
64	const Dir = struct {
65	putter_frame: @Frame(windowsDirReader),
66	file_table: FileTable,
67	dir_handle: os.windows.HANDLE,
68	};
69	};
70
71	const LinuxOsData = struct {
72	putter_frame: @Frame(linuxEventPutter),
73	inotify_fd: i32,
74	wd_table: WdTable,
75	table_lock: event.Lock,
76	cancelled: bool = false,
77
78	const WdTable = std.AutoHashMapUnmanaged(i32, Dir);
79	const FileTable = std.StringHashMapUnmanaged(V);
80
81	const Dir = struct {
82	dirname: []const u8,
83	file_table: FileTable,
84	};
85	};
86
87	const Self = @This();
88
89	pub const Event = struct {
90	id: Id,
91	data: V,
92	dirname: []const u8,
93	basename: []const u8,
94
95	pub const Id = WatchEventId;
96	pub const Error = WatchEventError;
97	};
98
99	pub fn init(allocator: Allocator, event_buf_count: usize) !*Self {
100	const self = try allocator.create(Self);
101	errdefer allocator.destroy(self);
102
103	switch (builtin.os.tag) {
104	.linux => {
105	const inotify_fd = try os.inotify_init1(os.linux.IN_NONBLOCK \| os.linux.IN_CLOEXEC);
106	errdefer os.close(inotify_fd);
107
108	self.* = Self{
109	.allocator = allocator,
110	.channel = undefined,
111	.os_data = OsData{
112	.putter_frame = undefined,
113	.inotify_fd = inotify_fd,
114	.wd_table = OsData.WdTable.init(allocator),
115	.table_lock = event.Lock{},
116	},
117	};
118
119	const buf = try allocator.alloc(Event.Error!Event, event_buf_count);
120	self.channel.init(buf);
121	self.os_data.putter_frame = async self.linuxEventPutter();
122	return self;
123	},
124
125	.windows => {
126	self.* = Self{
127	.allocator = allocator,
128	.channel = undefined,
129	.os_data = OsData{
130	.table_lock = event.Lock{},
131	.dir_table = OsData.DirTable.init(allocator),
132	},
133	};
134
135	const buf = try allocator.alloc(Event.Error!Event, event_buf_count);
136	self.channel.init(buf);
137	return self;
138	},
139
140	.macos, .freebsd, .netbsd, .dragonfly, .openbsd => {
141	self.* = Self{
142	.allocator = allocator,
143	.channel = undefined,
144	.os_data = OsData{
145	.table_lock = event.Lock{},
146	.file_table = OsData.FileTable.init(allocator),
147	},
148	};
149
150	const buf = try allocator.alloc(Event.Error!Event, event_buf_count);
151	self.channel.init(buf);
152	return self;
153	},
154	else => @compileError("Unsupported OS"),
155	}
156	}
157
158	pub fn deinit(self: *Self) void {
159	switch (builtin.os.tag) {
160	.macos, .freebsd, .netbsd, .dragonfly, .openbsd => {
161	var it = self.os_data.file_table.iterator();
162	while (it.next()) \|entry\| {
163	const key = entry.key_ptr.*;
164	const value = entry.value_ptr.*;
165	value.cancelled = true;
166	// @TODO Close the fd here?
167	await value.putter_frame;
168	self.allocator.free(key);
169	self.allocator.destroy(value);
170	}
171	},
172	.linux => {
173	self.os_data.cancelled = true;
174	{
175	// Remove all directory watches linuxEventPutter will take care of
176	// cleaning up the memory and closing the inotify fd.
177	var dir_it = self.os_data.wd_table.keyIterator();
178	while (dir_it.next()) \|wd_key\| {
179	const rc = os.linux.inotify_rm_watch(self.os_data.inotify_fd, wd_key.*);
180	// Errno can only be EBADF, EINVAL if either the inotify fs or the wd are invalid
181	std.debug.assert(rc == 0);
182	}
183	}
184	await self.os_data.putter_frame;
185	},
186	.windows => {
187	self.os_data.cancelled = true;
188	var dir_it = self.os_data.dir_table.iterator();
189	while (dir_it.next()) \|dir_entry\| {
190	if (windows.kernel32.CancelIoEx(dir_entry.value.dir_handle, null) != 0) {
191	// We canceled the pending ReadDirectoryChangesW operation, but our
192	// frame is still suspending, now waiting indefinitely.
193	// Thus, it is safe to resume it ourslves
194	resume dir_entry.value.putter_frame;
195	} else {
196	std.debug.assert(windows.kernel32.GetLastError() == .NOT_FOUND);
197	// We are at another suspend point, we can await safely for the
198	// function to exit the loop
199	await dir_entry.value.putter_frame;
200	}
201
202	self.allocator.free(dir_entry.key_ptr.*);
203	var file_it = dir_entry.value.file_table.keyIterator();
204	while (file_it.next()) \|file_entry\| {
205	self.allocator.free(file_entry.*);
206	}
207	dir_entry.value.file_table.deinit(self.allocator);
208	self.allocator.destroy(dir_entry.value_ptr.*);
209	}
210	self.os_data.dir_table.deinit(self.allocator);
211	},
212	else => @compileError("Unsupported OS"),
213	}
214	self.allocator.free(self.channel.buffer_nodes);
215	self.channel.deinit();
216	self.allocator.destroy(self);
217	}
218
219	pub fn addFile(self: *Self, file_path: []const u8, value: V) !?V {
220	switch (builtin.os.tag) {
221	.macos, .freebsd, .netbsd, .dragonfly, .openbsd => return addFileKEvent(self, file_path, value),
222	.linux => return addFileLinux(self, file_path, value),
223	.windows => return addFileWindows(self, file_path, value),
224	else => @compileError("Unsupported OS"),
225	}
226	}
227
228	fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {
229	var realpath_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
230	const realpath = try os.realpath(file_path, &realpath_buf);
231
232	const held = self.os_data.table_lock.acquire();
233	defer held.release();
234
235	const gop = try self.os_data.file_table.getOrPut(self.allocator, realpath);
236	errdefer assert(self.os_data.file_table.remove(realpath));
237	if (gop.found_existing) {
238	const prev_value = gop.value_ptr.value;
239	gop.value_ptr.value = value;
240	return prev_value;
241	}
242
243	gop.key_ptr.* = try self.allocator.dupe(u8, realpath);
244	errdefer self.allocator.free(gop.key_ptr.*);
245	gop.value_ptr.* = try self.allocator.create(OsData.Put);
246	errdefer self.allocator.destroy(gop.value_ptr.*);
247	gop.value_ptr.* = .{
248	.putter_frame = undefined,
249	.value = value,
250	};
251
252	// @TODO Can I close this fd and get an error from bsdWaitKev?
253	const flags = if (comptime builtin.target.isDarwin()) os.O.SYMLINK \| os.O.EVTONLY else 0;
254	const fd = try os.open(realpath, flags, 0);
255	gop.value_ptr.putter_frame = async self.kqPutEvents(fd, gop.key_ptr., gop.value_ptr.);
256	return null;
257	}
258
259	fn kqPutEvents(self: Self, fd: os.fd_t, file_path: []const u8, put: OsData.Put) void {
260	global_event_loop.beginOneEvent();
261	defer {
262	global_event_loop.finishOneEvent();
263	// @TODO: Remove this if we force close otherwise
264	os.close(fd);
265	}
266
267	// We need to manually do a bsdWaitKev to access the fflags.
268	var resume_node = event.Loop.ResumeNode.Basic{
269	.base = .{
270	.id = .Basic,
271	.handle = @frame(),
272	.overlapped = event.Loop.ResumeNode.overlapped_init,
273	},
274	.kev = undefined,
275	};
276
277	var kevs = [1]os.Kevent{undefined};
278	const kev = &kevs[0];
279
280	while (!put.cancelled) {
281	kev.* = os.Kevent{
282	.ident = @as(usize, @intCast(fd)),
283	.filter = os.EVFILT_VNODE,
284	.flags = os.EV_ADD \| os.EV_ENABLE \| os.EV_CLEAR \| os.EV_ONESHOT \|
285	os.NOTE_WRITE \| os.NOTE_DELETE \| os.NOTE_REVOKE,
286	.fflags = 0,
287	.data = 0,
288	.udata = @intFromPtr(&resume_node.base),
289	};
290	suspend {
291	global_event_loop.beginOneEvent();
292	errdefer global_event_loop.finishOneEvent();
293
294	const empty_kevs = &[0]os.Kevent{};
295	_ = os.kevent(global_event_loop.os_data.kqfd, &kevs, empty_kevs, null) catch \|err\| switch (err) {
296	error.EventNotFound,
297	error.ProcessNotFound,
298	error.Overflow,
299	=> unreachable,
300	error.AccessDenied, error.SystemResources => \|e\| {
301	self.channel.put(e);
302	continue;
303	},
304	};
305	}
306
307	if (kev.flags & os.EV_ERROR != 0) {
308	self.channel.put(os.unexpectedErrno(os.errno(kev.data)));
309	continue;
310	}
311
312	if (kev.fflags & os.NOTE_DELETE != 0 or kev.fflags & os.NOTE_REVOKE != 0) {
313	self.channel.put(Self.Event{
314	.id = .Delete,
315	.data = put.value,
316	.dirname = std.fs.path.dirname(file_path) orelse "/",
317	.basename = std.fs.path.basename(file_path),
318	});
319	} else if (kev.fflags & os.NOTE_WRITE != 0) {
320	self.channel.put(Self.Event{
321	.id = .CloseWrite,
322	.data = put.value,
323	.dirname = std.fs.path.dirname(file_path) orelse "/",
324	.basename = std.fs.path.basename(file_path),
325	});
326	}
327	}
328	}
329
330	fn addFileLinux(self: *Self, file_path: []const u8, value: V) !?V {
331	const dirname = std.fs.path.dirname(file_path) orelse if (file_path[0] == '/') "/" else ".";
332	const basename = std.fs.path.basename(file_path);
333
334	const wd = try os.inotify_add_watch(
335	self.os_data.inotify_fd,
336	dirname,
337	os.linux.IN_CLOSE_WRITE \| os.linux.IN_ONLYDIR \| os.linux.IN_DELETE \| os.linux.IN_EXCL_UNLINK,
338	);
339	// wd is either a newly created watch or an existing one.
340
341	const held = self.os_data.table_lock.acquire();
342	defer held.release();
343
344	const gop = try self.os_data.wd_table.getOrPut(self.allocator, wd);
345	errdefer assert(self.os_data.wd_table.remove(wd));
346	if (!gop.found_existing) {
347	gop.value_ptr.* = OsData.Dir{
348	.dirname = try self.allocator.dupe(u8, dirname),
349	.file_table = OsData.FileTable.init(self.allocator),
350	};
351	}
352
353	const dir = gop.value_ptr;
354	const file_table_gop = try dir.file_table.getOrPut(self.allocator, basename);
355	errdefer assert(dir.file_table.remove(basename));
356	if (file_table_gop.found_existing) {
357	const prev_value = file_table_gop.value_ptr.*;
358	file_table_gop.value_ptr.* = value;
359	return prev_value;
360	} else {
361	file_table_gop.key_ptr.* = try self.allocator.dupe(u8, basename);
362	file_table_gop.value_ptr.* = value;
363	return null;
364	}
365	}
366
367	fn addFileWindows(self: *Self, file_path: []const u8, value: V) !?V {
368	// TODO we might need to convert dirname and basename to canonical file paths ("short"?)
369	const dirname = std.fs.path.dirname(file_path) orelse if (file_path[0] == '/') "/" else ".";
370	var dirname_path_space: windows.PathSpace = undefined;
371	dirname_path_space.len = try std.unicode.utf8ToUtf16Le(&dirname_path_space.data, dirname);
372	dirname_path_space.data[dirname_path_space.len] = 0;
373
374	const basename = std.fs.path.basename(file_path);
375	var basename_path_space: windows.PathSpace = undefined;
376	basename_path_space.len = try std.unicode.utf8ToUtf16Le(&basename_path_space.data, basename);
377	basename_path_space.data[basename_path_space.len] = 0;
378
379	const held = self.os_data.table_lock.acquire();
380	defer held.release();
381
382	const gop = try self.os_data.dir_table.getOrPut(self.allocator, dirname);
383	errdefer assert(self.os_data.dir_table.remove(dirname));
384	if (gop.found_existing) {
385	const dir = gop.value_ptr.*;
386
387	const file_gop = try dir.file_table.getOrPut(self.allocator, basename);
388	errdefer assert(dir.file_table.remove(basename));
389	if (file_gop.found_existing) {
390	const prev_value = file_gop.value_ptr.*;
391	file_gop.value_ptr.* = value;
392	return prev_value;
393	} else {
394	file_gop.value_ptr.* = value;
395	file_gop.key_ptr.* = try self.allocator.dupe(u8, basename);
396	return null;
397	}
398	} else {
399	const dir_handle = try windows.OpenFile(dirname_path_space.span(), .{
400	.dir = std.fs.cwd().fd,
401	.access_mask = windows.FILE_LIST_DIRECTORY,
402	.creation = windows.FILE_OPEN,
403	.io_mode = .evented,
404	.filter = .dir_only,
405	});
406	errdefer windows.CloseHandle(dir_handle);
407
408	const dir = try self.allocator.create(OsData.Dir);
409	errdefer self.allocator.destroy(dir);
410
411	gop.key_ptr.* = try self.allocator.dupe(u8, dirname);
412	errdefer self.allocator.free(gop.key_ptr.*);
413
414	dir.* = OsData.Dir{
415	.file_table = OsData.FileTable.init(self.allocator),
416	.putter_frame = undefined,
417	.dir_handle = dir_handle,
418	};
419	gop.value_ptr.* = dir;
420	try dir.file_table.put(self.allocator, try self.allocator.dupe(u8, basename), value);
421	dir.putter_frame = async self.windowsDirReader(dir, gop.key_ptr.*);
422	return null;
423	}
424	}
425
426	fn windowsDirReader(self: Self, dir: OsData.Dir, dirname: []const u8) void {
427	defer os.close(dir.dir_handle);
428	var resume_node = Loop.ResumeNode.Basic{
429	.base = Loop.ResumeNode{
430	.id = .Basic,
431	.handle = @frame(),
432	.overlapped = windows.OVERLAPPED{
433	.Internal = 0,
434	.InternalHigh = 0,
435	.DUMMYUNIONNAME = .{
436	.DUMMYSTRUCTNAME = .{
437	.Offset = 0,
438	.OffsetHigh = 0,
439	},
440	},
441	.hEvent = null,
442	},
443	},
444	};
445
446	var event_buf: [4096]u8 align(@alignOf(windows.FILE_NOTIFY_INFORMATION)) = undefined;
447
448	global_event_loop.beginOneEvent();
449	defer global_event_loop.finishOneEvent();
450
451	while (!self.os_data.cancelled) main_loop: {
452	suspend {
453	_ = windows.kernel32.ReadDirectoryChangesW(
454	dir.dir_handle,
455	&event_buf,
456	event_buf.len,
457	windows.FALSE, // watch subtree
458	windows.FILE_NOTIFY_CHANGE_FILE_NAME \| windows.FILE_NOTIFY_CHANGE_DIR_NAME \|
459	windows.FILE_NOTIFY_CHANGE_ATTRIBUTES \| windows.FILE_NOTIFY_CHANGE_SIZE \|
460	windows.FILE_NOTIFY_CHANGE_LAST_WRITE \| windows.FILE_NOTIFY_CHANGE_LAST_ACCESS \|
461	windows.FILE_NOTIFY_CHANGE_CREATION \| windows.FILE_NOTIFY_CHANGE_SECURITY,
462	null, // number of bytes transferred (unused for async)
463	&resume_node.base.overlapped,
464	null, // completion routine - unused because we use IOCP
465	);
466	}
467
468	var bytes_transferred: windows.DWORD = undefined;
469	if (windows.kernel32.GetOverlappedResult(
470	dir.dir_handle,
471	&resume_node.base.overlapped,
472	&bytes_transferred,
473	windows.FALSE,
474	) == 0) {
475	const potential_error = windows.kernel32.GetLastError();
476	const err = switch (potential_error) {
477	.OPERATION_ABORTED, .IO_INCOMPLETE => err_blk: {
478	if (self.os_data.cancelled)
479	break :main_loop
480	else
481	break :err_blk windows.unexpectedError(potential_error);
482	},
483	else => \|err\| windows.unexpectedError(err),
484	};
485	self.channel.put(err);
486	} else {
487	var ptr: [*]u8 = &event_buf;
488	const end_ptr = ptr + bytes_transferred;
489	while (@intFromPtr(ptr) < @intFromPtr(end_ptr)) {
490	const ev = @as(*const windows.FILE_NOTIFY_INFORMATION, @ptrCast(ptr));
491	const emit = switch (ev.Action) {
492	windows.FILE_ACTION_REMOVED => WatchEventId.Delete,
493	windows.FILE_ACTION_MODIFIED => .CloseWrite,
494	else => null,
495	};
496	if (emit) \|id\| {
497	const basename_ptr = @as([*]u16, @ptrCast(ptr + @sizeOf(windows.FILE_NOTIFY_INFORMATION)));
498	const basename_utf16le = basename_ptr[0 .. ev.FileNameLength / 2];
499	var basename_data: [std.fs.MAX_PATH_BYTES]u8 = undefined;
500	const basename = basename_data[0 .. std.unicode.utf16LeToUtf8(&basename_data, basename_utf16le) catch unreachable];
501
502	if (dir.file_table.getEntry(basename)) \|entry\| {
503	self.channel.put(Event{
504	.id = id,
505	.data = entry.value_ptr.*,
506	.dirname = dirname,
507	.basename = entry.key_ptr.*,
508	});
509	}
510	}
511
512	if (ev.NextEntryOffset == 0) break;
513	ptr = @alignCast(ptr + ev.NextEntryOffset);
514	}
515	}
516	}
517	}
518
519	pub fn removeFile(self: *Self, file_path: []const u8) !?V {
520	switch (builtin.os.tag) {
521	.linux => {
522	const dirname = std.fs.path.dirname(file_path) orelse if (file_path[0] == '/') "/" else ".";
523	const basename = std.fs.path.basename(file_path);
524
525	const held = self.os_data.table_lock.acquire();
526	defer held.release();
527
528	const dir = self.os_data.wd_table.get(dirname) orelse return null;
529	if (dir.file_table.fetchRemove(basename)) \|file_entry\| {
530	self.allocator.free(file_entry.key);
531	return file_entry.value;
532	}
533	return null;
534	},
535	.windows => {
536	const dirname = std.fs.path.dirname(file_path) orelse if (file_path[0] == '/') "/" else ".";
537	const basename = std.fs.path.basename(file_path);
538
539	const held = self.os_data.table_lock.acquire();
540	defer held.release();
541
542	const dir = self.os_data.dir_table.get(dirname) orelse return null;
543	if (dir.file_table.fetchRemove(basename)) \|file_entry\| {
544	self.allocator.free(file_entry.key);
545	return file_entry.value;
546	}
547	return null;
548	},
549	.macos, .freebsd, .netbsd, .dragonfly, .openbsd => {
550	var realpath_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
551	const realpath = try os.realpath(file_path, &realpath_buf);
552
553	const held = self.os_data.table_lock.acquire();
554	defer held.release();
555
556	const entry = self.os_data.file_table.getEntry(realpath) orelse return null;
557	entry.value_ptr.cancelled = true;
558	// @TODO Close the fd here?
559	await entry.value_ptr.putter_frame;
560	self.allocator.free(entry.key_ptr.*);
561	self.allocator.destroy(entry.value_ptr.*);
562
563	assert(self.os_data.file_table.remove(realpath));
564	},
565	else => @compileError("Unsupported OS"),
566	}
567	}
568
569	fn linuxEventPutter(self: *Self) void {
570	global_event_loop.beginOneEvent();
571
572	defer {
573	std.debug.assert(self.os_data.wd_table.count() == 0);
574	self.os_data.wd_table.deinit(self.allocator);
575	os.close(self.os_data.inotify_fd);
576	self.allocator.free(self.channel.buffer_nodes);
577	self.channel.deinit();
578	global_event_loop.finishOneEvent();
579	}
580
581	var event_buf: [4096]u8 align(@alignOf(os.linux.inotify_event)) = undefined;
582
583	while (!self.os_data.cancelled) {
584	const bytes_read = global_event_loop.read(self.os_data.inotify_fd, &event_buf, false) catch unreachable;
585
586	var ptr: [*]u8 = &event_buf;
587	const end_ptr = ptr + bytes_read;
588	while (@intFromPtr(ptr) < @intFromPtr(end_ptr)) {
589	const ev = @as(*const os.linux.inotify_event, @ptrCast(ptr));
590	if (ev.mask & os.linux.IN_CLOSE_WRITE == os.linux.IN_CLOSE_WRITE) {
591	const basename_ptr = ptr + @sizeOf(os.linux.inotify_event);
592	const basename = std.mem.span(@as([*:0]u8, @ptrCast(basename_ptr)));
593
594	const dir = &self.os_data.wd_table.get(ev.wd).?;
595	if (dir.file_table.getEntry(basename)) \|file_value\| {
596	self.channel.put(Event{
597	.id = .CloseWrite,
598	.data = file_value.value_ptr.*,
599	.dirname = dir.dirname,
600	.basename = file_value.key_ptr.*,
601	});
602	}
603	} else if (ev.mask & os.linux.IN_IGNORED == os.linux.IN_IGNORED) {
604	// Directory watch was removed
605	const held = self.os_data.table_lock.acquire();
606	defer held.release();
607	if (self.os_data.wd_table.fetchRemove(ev.wd)) \|wd_entry\| {
608	var file_it = wd_entry.value.file_table.keyIterator();
609	while (file_it.next()) \|file_entry\| {
610	self.allocator.free(file_entry.*);
611	}
612	self.allocator.free(wd_entry.value.dirname);
613	wd_entry.value.file_table.deinit(self.allocator);
614	}
615	} else if (ev.mask & os.linux.IN_DELETE == os.linux.IN_DELETE) {
616	// File or directory was removed or deleted
617	const basename_ptr = ptr + @sizeOf(os.linux.inotify_event);
618	const basename = std.mem.span(@as([*:0]u8, @ptrCast(basename_ptr)));
619
620	const dir = &self.os_data.wd_table.get(ev.wd).?;
621	if (dir.file_table.getEntry(basename)) \|file_value\| {
622	self.channel.put(Event{
623	.id = .Delete,
624	.data = file_value.value_ptr.*,
625	.dirname = dir.dirname,
626	.basename = file_value.key_ptr.*,
627	});
628	}
629	}
630
631	ptr = @alignCast(ptr + @sizeOf(os.linux.inotify_event) + ev.len);
632	}
633	}
634	}
635	};
636	}
637
638	const test_tmp_dir = "std_event_fs_test";
639
640	test "write a file, watch it, write it again, delete it" {
641	if (!std.io.is_async) return error.SkipZigTest;
642	// TODO https://github.com/ziglang/zig/issues/1908
643	if (builtin.single_threaded) return error.SkipZigTest;
644
645	try std.fs.cwd().makePath(test_tmp_dir);
646	defer std.fs.cwd().deleteTree(test_tmp_dir) catch {};
647
648	return testWriteWatchWriteDelete(std.testing.allocator);
649	}
650
651	fn testWriteWatchWriteDelete(allocator: Allocator) !void {
652	const file_path = try std.fs.path.join(allocator, &[_][]const u8{ test_tmp_dir, "file.txt" });
653	defer allocator.free(file_path);
654
655	const contents =
656	\\line 1
657	\\line 2
658	;
659	const line2_offset = 7;
660
661	// first just write then read the file
662	try std.fs.cwd().writeFile(file_path, contents);
663
664	const read_contents = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);
665	defer allocator.free(read_contents);
666	try testing.expectEqualSlices(u8, contents, read_contents);
667
668	// now watch the file
669	var watch = try Watch(void).init(allocator, 0);
670	defer watch.deinit();
671
672	try testing.expect((try watch.addFile(file_path, {})) == null);
673
674	var ev = async watch.channel.get();
675	var ev_consumed = false;
676	defer if (!ev_consumed) {
677	_ = await ev;
678	};
679
680	// overwrite line 2
681	const file = try std.fs.cwd().openFile(file_path, .{ .mode = .read_write });
682	{
683	defer file.close();
684	const write_contents = "lorem ipsum";
685	var iovec = [_]os.iovec_const{.{
686	.iov_base = write_contents,
687	.iov_len = write_contents.len,
688	}};
689	_ = try file.pwritevAll(&iovec, line2_offset);
690	}
691
692	switch ((try await ev).id) {
693	.CloseWrite => {
694	ev_consumed = true;
695	},
696	.Delete => @panic("wrong event"),
697	}
698
699	const contents_updated = try std.fs.cwd().readFileAlloc(allocator, file_path, 1024 * 1024);
700	defer allocator.free(contents_updated);
701
702	try testing.expectEqualSlices(u8,
703	\\line 1
704	\\lorem ipsum
705	, contents_updated);
706
707	ev = async watch.channel.get();
708	ev_consumed = false;
709
710	try std.fs.cwd().deleteFile(file_path);
711	switch ((try await ev).id) {
712	.Delete => {
713	ev_consumed = true;
714	},
715	.CloseWrite => @panic("wrong event"),
716	}
717	}
718
719	// TODO Test: Add another file watch, remove the old file watch, get an event in the new

lib/std/os.zig+257-40

...	@@ -3,7 +3,7 @@	...	@@ -3,7 +3,7 @@
3	//! * Convert "errno"-style error codes into Zig errors.	3	//! * Convert "errno"-style error codes into Zig errors.
4	//! * When null-terminated byte buffers are required, provide APIs which accept	4	//! * When null-terminated byte buffers are required, provide APIs which accept
5	//! slices as well as APIs which accept null-terminated byte buffers. Same goes	5	//! slices as well as APIs which accept null-terminated byte buffers. Same goes
6	//! for UTF-16LE encoding.	6	//! for WTF-16LE encoding.
7	//! * Where operating systems share APIs, e.g. POSIX, these thin wrappers provide	7	//! * Where operating systems share APIs, e.g. POSIX, these thin wrappers provide
8	//! cross platform abstracting.	8	//! cross platform abstracting.
9	//! * When there exists a corresponding libc function and linking libc, the libc	9	//! * When there exists a corresponding libc function and linking libc, the libc
...	@@ -498,6 +498,7 @@ fn fchmodat2(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtEr	...	@@ -498,6 +498,7 @@ fn fchmodat2(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtEr
498	const stat = fstatatZ(pathfd, "", AT.EMPTY_PATH) catch \|err\| switch (err) {	498	const stat = fstatatZ(pathfd, "", AT.EMPTY_PATH) catch \|err\| switch (err) {
499	error.NameTooLong => unreachable,	499	error.NameTooLong => unreachable,
500	error.FileNotFound => unreachable,	500	error.FileNotFound => unreachable,
		501	error.InvalidUtf8 => unreachable,
501	else => \|e\| return e,	502	else => \|e\| return e,
502	};	503	};
503	if ((stat.mode & S.IFMT) == S.IFLNK)	504	if ((stat.mode & S.IFMT) == S.IFLNK)
...	@@ -1614,9 +1615,16 @@ pub const OpenError = error{	...	@@ -1614,9 +1615,16 @@ pub const OpenError = error{
1614	/// The underlying filesystem does not support file locks	1615	/// The underlying filesystem does not support file locks
1615	FileLocksNotSupported,	1616	FileLocksNotSupported,
1616		1617
		1618	/// Path contains characters that are disallowed by the underlying filesystem.
1617	BadPathName,	1619	BadPathName,
		1620
		1621	/// WASI-only; file paths must be valid UTF-8.
1618	InvalidUtf8,	1622	InvalidUtf8,
1619		1623
		1624	/// Windows-only; file paths provided by the user must be valid WTF-8.
		1625	/// https://simonsapin.github.io/wtf-8/
		1626	InvalidWtf8,
		1627
1620	/// On Windows, `\\server` or `\\server\share` was not found.	1628	/// On Windows, `\\server` or `\\server\share` was not found.
1621	NetworkNotFound,	1629	NetworkNotFound,
1622		1630
...	@@ -1634,6 +1642,9 @@ pub const OpenError = error{	...	@@ -1634,6 +1642,9 @@ pub const OpenError = error{
1634	} \|\| UnexpectedError;	1642	} \|\| UnexpectedError;
1635		1643
1636	/// Open and possibly create a file. Keeps trying if it gets interrupted.	1644	/// Open and possibly create a file. Keeps trying if it gets interrupted.
		1645	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		1646	/// On WASI, `file_path` should be encoded as valid UTF-8.
		1647	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
1637	/// See also `openZ`.	1648	/// See also `openZ`.
1638	pub fn open(file_path: []const u8, flags: O, perm: mode_t) OpenError!fd_t {	1649	pub fn open(file_path: []const u8, flags: O, perm: mode_t) OpenError!fd_t {
1639	if (builtin.os.tag == .windows) {	1650	if (builtin.os.tag == .windows) {
...	@@ -1646,6 +1657,9 @@ pub fn open(file_path: []const u8, flags: O, perm: mode_t) OpenError!fd_t {	...	@@ -1646,6 +1657,9 @@ pub fn open(file_path: []const u8, flags: O, perm: mode_t) OpenError!fd_t {
1646	}	1657	}
1647		1658
1648	/// Open and possibly create a file. Keeps trying if it gets interrupted.	1659	/// Open and possibly create a file. Keeps trying if it gets interrupted.
		1660	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		1661	/// On WASI, `file_path` should be encoded as valid UTF-8.
		1662	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
1649	/// See also `open`.	1663	/// See also `open`.
1650	pub fn openZ(file_path: [*:0]const u8, flags: O, perm: mode_t) OpenError!fd_t {	1664	pub fn openZ(file_path: [*:0]const u8, flags: O, perm: mode_t) OpenError!fd_t {
1651	if (builtin.os.tag == .windows) {	1665	if (builtin.os.tag == .windows) {
...	@@ -1687,6 +1701,9 @@ pub fn openZ(file_path: [*:0]const u8, flags: O, perm: mode_t) OpenError!fd_t {	...	@@ -1687,6 +1701,9 @@ pub fn openZ(file_path: [*:0]const u8, flags: O, perm: mode_t) OpenError!fd_t {
1687		1701
1688	/// Open and possibly create a file. Keeps trying if it gets interrupted.	1702	/// Open and possibly create a file. Keeps trying if it gets interrupted.
1689	/// `file_path` is relative to the open directory handle `dir_fd`.	1703	/// `file_path` is relative to the open directory handle `dir_fd`.
		1704	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		1705	/// On WASI, `file_path` should be encoded as valid UTF-8.
		1706	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
1690	/// See also `openatZ`.	1707	/// See also `openatZ`.
1691	pub fn openat(dir_fd: fd_t, file_path: []const u8, flags: O, mode: mode_t) OpenError!fd_t {	1708	pub fn openat(dir_fd: fd_t, file_path: []const u8, flags: O, mode: mode_t) OpenError!fd_t {
1692	if (builtin.os.tag == .windows) {	1709	if (builtin.os.tag == .windows) {
...	@@ -1829,6 +1846,7 @@ pub fn openatWasi(	...	@@ -1829,6 +1846,7 @@ pub fn openatWasi(
1829	.EXIST => return error.PathAlreadyExists,	1846	.EXIST => return error.PathAlreadyExists,
1830	.BUSY => return error.DeviceBusy,	1847	.BUSY => return error.DeviceBusy,
1831	.NOTCAPABLE => return error.AccessDenied,	1848	.NOTCAPABLE => return error.AccessDenied,
		1849	.ILSEQ => return error.InvalidUtf8,
1832	else => \|err\| return unexpectedErrno(err),	1850	else => \|err\| return unexpectedErrno(err),
1833	}	1851	}
1834	}	1852	}
...	@@ -1836,6 +1854,9 @@ pub fn openatWasi(	...	@@ -1836,6 +1854,9 @@ pub fn openatWasi(
1836		1854
1837	/// Open and possibly create a file. Keeps trying if it gets interrupted.	1855	/// Open and possibly create a file. Keeps trying if it gets interrupted.
1838	/// `file_path` is relative to the open directory handle `dir_fd`.	1856	/// `file_path` is relative to the open directory handle `dir_fd`.
		1857	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		1858	/// On WASI, `file_path` should be encoded as valid UTF-8.
		1859	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
1839	/// See also `openat`.	1860	/// See also `openat`.
1840	pub fn openatZ(dir_fd: fd_t, file_path: [*:0]const u8, flags: O, mode: mode_t) OpenError!fd_t {	1861	pub fn openatZ(dir_fd: fd_t, file_path: [*:0]const u8, flags: O, mode: mode_t) OpenError!fd_t {
1841	if (builtin.os.tag == .windows) {	1862	if (builtin.os.tag == .windows) {
...	@@ -2156,13 +2177,23 @@ pub const SymLinkError = error{	...	@@ -2156,13 +2177,23 @@ pub const SymLinkError = error{
2156	ReadOnlyFileSystem,	2177	ReadOnlyFileSystem,
2157	NotDir,	2178	NotDir,
2158	NameTooLong,	2179	NameTooLong,
		2180
		2181	/// WASI-only; file paths must be valid UTF-8.
2159	InvalidUtf8,	2182	InvalidUtf8,
		2183
		2184	/// Windows-only; file paths provided by the user must be valid WTF-8.
		2185	/// https://simonsapin.github.io/wtf-8/
		2186	InvalidWtf8,
		2187
2160	BadPathName,	2188	BadPathName,
2161	} \|\| UnexpectedError;	2189	} \|\| UnexpectedError;
2162		2190
2163	/// Creates a symbolic link named `sym_link_path` which contains the string `target_path`.	2191	/// Creates a symbolic link named `sym_link_path` which contains the string `target_path`.
2164	/// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent	2192	/// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent
2165	/// one; the latter case is known as a dangling link.	2193	/// one; the latter case is known as a dangling link.
		2194	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2195	/// On WASI, both paths should be encoded as valid UTF-8.
		2196	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2166	/// If `sym_link_path` exists, it will not be overwritten.	2197	/// If `sym_link_path` exists, it will not be overwritten.
2167	/// See also `symlinkZ.	2198	/// See also `symlinkZ.
2168	pub fn symlink(target_path: []const u8, sym_link_path: []const u8) SymLinkError!void {	2199	pub fn symlink(target_path: []const u8, sym_link_path: []const u8) SymLinkError!void {
...	@@ -2200,6 +2231,10 @@ pub fn symlinkZ(target_path: [:0]const u8, sym_link_path: [:0]const u8) SymLin	...	@@ -2200,6 +2231,10 @@ pub fn symlinkZ(target_path: [:0]const u8, sym_link_path: [:0]const u8) SymLin
2200	.NOMEM => return error.SystemResources,	2231	.NOMEM => return error.SystemResources,
2201	.NOSPC => return error.NoSpaceLeft,	2232	.NOSPC => return error.NoSpaceLeft,
2202	.ROFS => return error.ReadOnlyFileSystem,	2233	.ROFS => return error.ReadOnlyFileSystem,
		2234	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2235	return error.InvalidUtf8
		2236	else
		2237	return unexpectedErrno(err),
2203	else => \|err\| return unexpectedErrno(err),	2238	else => \|err\| return unexpectedErrno(err),
2204	}	2239	}
2205	}	2240	}
...	@@ -2208,6 +2243,9 @@ pub fn symlinkZ(target_path: [:0]const u8, sym_link_path: [:0]const u8) SymLin	...	@@ -2208,6 +2243,9 @@ pub fn symlinkZ(target_path: [:0]const u8, sym_link_path: [:0]const u8) SymLin
2208	/// `target_path` relative to `newdirfd` directory handle.	2243	/// `target_path` relative to `newdirfd` directory handle.
2209	/// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent	2244	/// A symbolic link (also known as a soft link) may point to an existing file or to a nonexistent
2210	/// one; the latter case is known as a dangling link.	2245	/// one; the latter case is known as a dangling link.
		2246	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2247	/// On WASI, both paths should be encoded as valid UTF-8.
		2248	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2211	/// If `sym_link_path` exists, it will not be overwritten.	2249	/// If `sym_link_path` exists, it will not be overwritten.
2212	/// See also `symlinkatWasi`, `symlinkatZ` and `symlinkatW`.	2250	/// See also `symlinkatWasi`, `symlinkatZ` and `symlinkatW`.
2213	pub fn symlinkat(target_path: []const u8, newdirfd: fd_t, sym_link_path: []const u8) SymLinkError!void {	2251	pub fn symlinkat(target_path: []const u8, newdirfd: fd_t, sym_link_path: []const u8) SymLinkError!void {
...	@@ -2242,6 +2280,7 @@ pub fn symlinkatWasi(target_path: []const u8, newdirfd: fd_t, sym_link_path: []c	...	@@ -2242,6 +2280,7 @@ pub fn symlinkatWasi(target_path: []const u8, newdirfd: fd_t, sym_link_path: []c
2242	.NOSPC => return error.NoSpaceLeft,	2280	.NOSPC => return error.NoSpaceLeft,
2243	.ROFS => return error.ReadOnlyFileSystem,	2281	.ROFS => return error.ReadOnlyFileSystem,
2244	.NOTCAPABLE => return error.AccessDenied,	2282	.NOTCAPABLE => return error.AccessDenied,
		2283	.ILSEQ => return error.InvalidUtf8,
2245	else => \|err\| return unexpectedErrno(err),	2284	else => \|err\| return unexpectedErrno(err),
2246	}	2285	}
2247	}	2286	}
...	@@ -2270,6 +2309,10 @@ pub fn symlinkatZ(target_path: [:0]const u8, newdirfd: fd_t, sym_link_path: [:	...	@@ -2270,6 +2309,10 @@ pub fn symlinkatZ(target_path: [:0]const u8, newdirfd: fd_t, sym_link_path: [:
2270	.NOMEM => return error.SystemResources,	2309	.NOMEM => return error.SystemResources,
2271	.NOSPC => return error.NoSpaceLeft,	2310	.NOSPC => return error.NoSpaceLeft,
2272	.ROFS => return error.ReadOnlyFileSystem,	2311	.ROFS => return error.ReadOnlyFileSystem,
		2312	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2313	return error.InvalidUtf8
		2314	else
		2315	return unexpectedErrno(err),
2273	else => \|err\| return unexpectedErrno(err),	2316	else => \|err\| return unexpectedErrno(err),
2274	}	2317	}
2275	}	2318	}
...	@@ -2287,8 +2330,13 @@ pub const LinkError = UnexpectedError \|\| error{	...	@@ -2287,8 +2330,13 @@ pub const LinkError = UnexpectedError \|\| error{
2287	NoSpaceLeft,	2330	NoSpaceLeft,
2288	ReadOnlyFileSystem,	2331	ReadOnlyFileSystem,
2289	NotSameFileSystem,	2332	NotSameFileSystem,
		2333
		2334	/// WASI-only; file paths must be valid UTF-8.
		2335	InvalidUtf8,
2290	};	2336	};
2291		2337
		2338	/// On WASI, both paths should be encoded as valid UTF-8.
		2339	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2292	pub fn linkZ(oldpath: [:0]const u8, newpath: [:0]const u8, flags: i32) LinkError!void {	2340	pub fn linkZ(oldpath: [:0]const u8, newpath: [:0]const u8, flags: i32) LinkError!void {
2293	if (builtin.os.tag == .wasi and !builtin.link_libc) {	2341	if (builtin.os.tag == .wasi and !builtin.link_libc) {
2294	return link(mem.sliceTo(oldpath, 0), mem.sliceTo(newpath, 0), flags);	2342	return link(mem.sliceTo(oldpath, 0), mem.sliceTo(newpath, 0), flags);
...	@@ -2310,10 +2358,16 @@ pub fn linkZ(oldpath: [:0]const u8, newpath: [:0]const u8, flags: i32) LinkErr	...	@@ -2310,10 +2358,16 @@ pub fn linkZ(oldpath: [:0]const u8, newpath: [:0]const u8, flags: i32) LinkErr
2310	.ROFS => return error.ReadOnlyFileSystem,	2358	.ROFS => return error.ReadOnlyFileSystem,
2311	.XDEV => return error.NotSameFileSystem,	2359	.XDEV => return error.NotSameFileSystem,
2312	.INVAL => unreachable,	2360	.INVAL => unreachable,
		2361	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2362	return error.InvalidUtf8
		2363	else
		2364	return unexpectedErrno(err),
2313	else => \|err\| return unexpectedErrno(err),	2365	else => \|err\| return unexpectedErrno(err),
2314	}	2366	}
2315	}	2367	}
2316		2368
		2369	/// On WASI, both paths should be encoded as valid UTF-8.
		2370	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2317	pub fn link(oldpath: []const u8, newpath: []const u8, flags: i32) LinkError!void {	2371	pub fn link(oldpath: []const u8, newpath: []const u8, flags: i32) LinkError!void {
2318	if (builtin.os.tag == .wasi and !builtin.link_libc) {	2372	if (builtin.os.tag == .wasi and !builtin.link_libc) {
2319	return linkat(wasi.AT.FDCWD, oldpath, wasi.AT.FDCWD, newpath, flags) catch \|err\| switch (err) {	2373	return linkat(wasi.AT.FDCWD, oldpath, wasi.AT.FDCWD, newpath, flags) catch \|err\| switch (err) {
...	@@ -2328,6 +2382,8 @@ pub fn link(oldpath: []const u8, newpath: []const u8, flags: i32) LinkError!void	...	@@ -2328,6 +2382,8 @@ pub fn link(oldpath: []const u8, newpath: []const u8, flags: i32) LinkError!void
2328		2382
2329	pub const LinkatError = LinkError \|\| error{NotDir};	2383	pub const LinkatError = LinkError \|\| error{NotDir};
2330		2384
		2385	/// On WASI, both paths should be encoded as valid UTF-8.
		2386	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2331	pub fn linkatZ(	2387	pub fn linkatZ(
2332	olddir: fd_t,	2388	olddir: fd_t,
2333	oldpath: [*:0]const u8,	2389	oldpath: [*:0]const u8,
...	@@ -2356,10 +2412,16 @@ pub fn linkatZ(	...	@@ -2356,10 +2412,16 @@ pub fn linkatZ(
2356	.ROFS => return error.ReadOnlyFileSystem,	2412	.ROFS => return error.ReadOnlyFileSystem,
2357	.XDEV => return error.NotSameFileSystem,	2413	.XDEV => return error.NotSameFileSystem,
2358	.INVAL => unreachable,	2414	.INVAL => unreachable,
		2415	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2416	return error.InvalidUtf8
		2417	else
		2418	return unexpectedErrno(err),
2359	else => \|err\| return unexpectedErrno(err),	2419	else => \|err\| return unexpectedErrno(err),
2360	}	2420	}
2361	}	2421	}
2362		2422
		2423	/// On WASI, both paths should be encoded as valid UTF-8.
		2424	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2363	pub fn linkat(	2425	pub fn linkat(
2364	olddir: fd_t,	2426	olddir: fd_t,
2365	oldpath: []const u8,	2427	oldpath: []const u8,
...	@@ -2399,6 +2461,7 @@ pub fn linkat(	...	@@ -2399,6 +2461,7 @@ pub fn linkat(
2399	.ROFS => return error.ReadOnlyFileSystem,	2461	.ROFS => return error.ReadOnlyFileSystem,
2400	.XDEV => return error.NotSameFileSystem,	2462	.XDEV => return error.NotSameFileSystem,
2401	.INVAL => unreachable,	2463	.INVAL => unreachable,
		2464	.ILSEQ => return error.InvalidUtf8,
2402	else => \|err\| return unexpectedErrno(err),	2465	else => \|err\| return unexpectedErrno(err),
2403	}	2466	}
2404	}	2467	}
...	@@ -2422,9 +2485,13 @@ pub const UnlinkError = error{	...	@@ -2422,9 +2485,13 @@ pub const UnlinkError = error{
2422	SystemResources,	2485	SystemResources,
2423	ReadOnlyFileSystem,	2486	ReadOnlyFileSystem,
2424		2487
2425	/// On Windows, file paths must be valid Unicode.	2488	/// WASI-only; file paths must be valid UTF-8.
2426	InvalidUtf8,	2489	InvalidUtf8,
2427		2490
		2491	/// Windows-only; file paths provided by the user must be valid WTF-8.
		2492	/// https://simonsapin.github.io/wtf-8/
		2493	InvalidWtf8,
		2494
2428	/// On Windows, file paths cannot contain these characters:	2495	/// On Windows, file paths cannot contain these characters:
2429	/// '/', '*', '?', '"', '<', '>', '\|'	2496	/// '/', '*', '?', '"', '<', '>', '\|'
2430	BadPathName,	2497	BadPathName,
...	@@ -2434,6 +2501,9 @@ pub const UnlinkError = error{	...	@@ -2434,6 +2501,9 @@ pub const UnlinkError = error{
2434	} \|\| UnexpectedError;	2501	} \|\| UnexpectedError;
2435		2502
2436	/// Delete a name and possibly the file it refers to.	2503	/// Delete a name and possibly the file it refers to.
		2504	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2505	/// On WASI, `file_path` should be encoded as valid UTF-8.
		2506	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
2437	/// See also `unlinkZ`.	2507	/// See also `unlinkZ`.
2438	pub fn unlink(file_path: []const u8) UnlinkError!void {	2508	pub fn unlink(file_path: []const u8) UnlinkError!void {
2439	if (builtin.os.tag == .wasi and !builtin.link_libc) {	2509	if (builtin.os.tag == .wasi and !builtin.link_libc) {
...	@@ -2450,7 +2520,7 @@ pub fn unlink(file_path: []const u8) UnlinkError!void {	...	@@ -2450,7 +2520,7 @@ pub fn unlink(file_path: []const u8) UnlinkError!void {
2450	}	2520	}
2451	}	2521	}
2452		2522
2453	/// Same as `unlink` except the parameter is a null terminated UTF8-encoded string.	2523	/// Same as `unlink` except the parameter is null terminated.
2454	pub fn unlinkZ(file_path: [*:0]const u8) UnlinkError!void {	2524	pub fn unlinkZ(file_path: [*:0]const u8) UnlinkError!void {
2455	if (builtin.os.tag == .windows) {	2525	if (builtin.os.tag == .windows) {
2456	const file_path_w = try windows.cStrToPrefixedFileW(null, file_path);	2526	const file_path_w = try windows.cStrToPrefixedFileW(null, file_path);
...	@@ -2473,11 +2543,15 @@ pub fn unlinkZ(file_path: [*:0]const u8) UnlinkError!void {	...	@@ -2473,11 +2543,15 @@ pub fn unlinkZ(file_path: [*:0]const u8) UnlinkError!void {
2473	.NOTDIR => return error.NotDir,	2543	.NOTDIR => return error.NotDir,
2474	.NOMEM => return error.SystemResources,	2544	.NOMEM => return error.SystemResources,
2475	.ROFS => return error.ReadOnlyFileSystem,	2545	.ROFS => return error.ReadOnlyFileSystem,
		2546	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2547	return error.InvalidUtf8
		2548	else
		2549	return unexpectedErrno(err),
2476	else => \|err\| return unexpectedErrno(err),	2550	else => \|err\| return unexpectedErrno(err),
2477	}	2551	}
2478	}	2552	}
2479		2553
2480	/// Windows-only. Same as `unlink` except the parameter is null-terminated, WTF16 encoded.	2554	/// Windows-only. Same as `unlink` except the parameter is null-terminated, WTF16 LE encoded.
2481	pub fn unlinkW(file_path_w: []const u16) UnlinkError!void {	2555	pub fn unlinkW(file_path_w: []const u16) UnlinkError!void {
2482	windows.DeleteFile(file_path_w, .{ .dir = std.fs.cwd().fd }) catch \|err\| switch (err) {	2556	windows.DeleteFile(file_path_w, .{ .dir = std.fs.cwd().fd }) catch \|err\| switch (err) {
2483	error.DirNotEmpty => unreachable, // we're not passing .remove_dir = true	2557	error.DirNotEmpty => unreachable, // we're not passing .remove_dir = true
...	@@ -2491,6 +2565,9 @@ pub const UnlinkatError = UnlinkError \|\| error{	...	@@ -2491,6 +2565,9 @@ pub const UnlinkatError = UnlinkError \|\| error{
2491	};	2565	};
2492		2566
2493	/// Delete a file name and possibly the file it refers to, based on an open directory handle.	2567	/// Delete a file name and possibly the file it refers to, based on an open directory handle.
		2568	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2569	/// On WASI, `file_path` should be encoded as valid UTF-8.
		2570	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
2494	/// Asserts that the path parameter has no null bytes.	2571	/// Asserts that the path parameter has no null bytes.
2495	pub fn unlinkat(dirfd: fd_t, file_path: []const u8, flags: u32) UnlinkatError!void {	2572	pub fn unlinkat(dirfd: fd_t, file_path: []const u8, flags: u32) UnlinkatError!void {
2496	if (builtin.os.tag == .windows) {	2573	if (builtin.os.tag == .windows) {
...	@@ -2528,6 +2605,7 @@ pub fn unlinkatWasi(dirfd: fd_t, file_path: []const u8, flags: u32) UnlinkatErro	...	@@ -2528,6 +2605,7 @@ pub fn unlinkatWasi(dirfd: fd_t, file_path: []const u8, flags: u32) UnlinkatErro
2528	.ROFS => return error.ReadOnlyFileSystem,	2605	.ROFS => return error.ReadOnlyFileSystem,
2529	.NOTEMPTY => return error.DirNotEmpty,	2606	.NOTEMPTY => return error.DirNotEmpty,
2530	.NOTCAPABLE => return error.AccessDenied,	2607	.NOTCAPABLE => return error.AccessDenied,
		2608	.ILSEQ => return error.InvalidUtf8,
2531		2609
2532	.INVAL => unreachable, // invalid flags, or pathname has . as last component	2610	.INVAL => unreachable, // invalid flags, or pathname has . as last component
2533	.BADF => unreachable, // always a race condition	2611	.BADF => unreachable, // always a race condition
...	@@ -2560,6 +2638,10 @@ pub fn unlinkatZ(dirfd: fd_t, file_path_c: [*:0]const u8, flags: u32) UnlinkatEr	...	@@ -2560,6 +2638,10 @@ pub fn unlinkatZ(dirfd: fd_t, file_path_c: [*:0]const u8, flags: u32) UnlinkatEr
2560	.ROFS => return error.ReadOnlyFileSystem,	2638	.ROFS => return error.ReadOnlyFileSystem,
2561	.EXIST => return error.DirNotEmpty,	2639	.EXIST => return error.DirNotEmpty,
2562	.NOTEMPTY => return error.DirNotEmpty,	2640	.NOTEMPTY => return error.DirNotEmpty,
		2641	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2642	return error.InvalidUtf8
		2643	else
		2644	return unexpectedErrno(err),
2563		2645
2564	.INVAL => unreachable, // invalid flags, or pathname has . as last component	2646	.INVAL => unreachable, // invalid flags, or pathname has . as last component
2565	.BADF => unreachable, // always a race condition	2647	.BADF => unreachable, // always a race condition
...	@@ -2568,7 +2650,7 @@ pub fn unlinkatZ(dirfd: fd_t, file_path_c: [*:0]const u8, flags: u32) UnlinkatEr	...	@@ -2568,7 +2650,7 @@ pub fn unlinkatZ(dirfd: fd_t, file_path_c: [*:0]const u8, flags: u32) UnlinkatEr
2568	}	2650	}
2569	}	2651	}
2570		2652
2571	/// Same as `unlinkat` but `sub_path_w` is UTF16LE, NT prefixed. Windows only.	2653	/// Same as `unlinkat` but `sub_path_w` is WTF16LE, NT prefixed. Windows only.
2572	pub fn unlinkatW(dirfd: fd_t, sub_path_w: []const u16, flags: u32) UnlinkatError!void {	2654	pub fn unlinkatW(dirfd: fd_t, sub_path_w: []const u16, flags: u32) UnlinkatError!void {
2573	const remove_dir = (flags & AT.REMOVEDIR) != 0;	2655	const remove_dir = (flags & AT.REMOVEDIR) != 0;
2574	return windows.DeleteFile(sub_path_w, .{ .dir = dirfd, .remove_dir = remove_dir });	2656	return windows.DeleteFile(sub_path_w, .{ .dir = dirfd, .remove_dir = remove_dir });
...	@@ -2594,7 +2676,11 @@ pub const RenameError = error{	...	@@ -2594,7 +2676,11 @@ pub const RenameError = error{
2594	PathAlreadyExists,	2676	PathAlreadyExists,
2595	ReadOnlyFileSystem,	2677	ReadOnlyFileSystem,
2596	RenameAcrossMountPoints,	2678	RenameAcrossMountPoints,
		2679	/// WASI-only; file paths must be valid UTF-8.
2597	InvalidUtf8,	2680	InvalidUtf8,
		2681	/// Windows-only; file paths provided by the user must be valid WTF-8.
		2682	/// https://simonsapin.github.io/wtf-8/
		2683	InvalidWtf8,
2598	BadPathName,	2684	BadPathName,
2599	NoDevice,	2685	NoDevice,
2600	SharingViolation,	2686	SharingViolation,
...	@@ -2610,6 +2696,9 @@ pub const RenameError = error{	...	@@ -2610,6 +2696,9 @@ pub const RenameError = error{
2610	} \|\| UnexpectedError;	2696	} \|\| UnexpectedError;
2611		2697
2612	/// Change the name or location of a file.	2698	/// Change the name or location of a file.
		2699	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2700	/// On WASI, both paths should be encoded as valid UTF-8.
		2701	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2613	pub fn rename(old_path: []const u8, new_path: []const u8) RenameError!void {	2702	pub fn rename(old_path: []const u8, new_path: []const u8) RenameError!void {
2614	if (builtin.os.tag == .wasi and !builtin.link_libc) {	2703	if (builtin.os.tag == .wasi and !builtin.link_libc) {
2615	return renameat(wasi.AT.FDCWD, old_path, wasi.AT.FDCWD, new_path);	2704	return renameat(wasi.AT.FDCWD, old_path, wasi.AT.FDCWD, new_path);
...	@@ -2624,7 +2713,7 @@ pub fn rename(old_path: []const u8, new_path: []const u8) RenameError!void {	...	@@ -2624,7 +2713,7 @@ pub fn rename(old_path: []const u8, new_path: []const u8) RenameError!void {
2624	}	2713	}
2625	}	2714	}
2626		2715
2627	/// Same as `rename` except the parameters are null-terminated byte arrays.	2716	/// Same as `rename` except the parameters are null-terminated.
2628	pub fn renameZ(old_path: [:0]const u8, new_path: [:0]const u8) RenameError!void {	2717	pub fn renameZ(old_path: [:0]const u8, new_path: [:0]const u8) RenameError!void {
2629	if (builtin.os.tag == .windows) {	2718	if (builtin.os.tag == .windows) {
2630	const old_path_w = try windows.cStrToPrefixedFileW(null, old_path);	2719	const old_path_w = try windows.cStrToPrefixedFileW(null, old_path);
...	@@ -2653,11 +2742,15 @@ pub fn renameZ(old_path: [:0]const u8, new_path: [:0]const u8) RenameError!voi	...	@@ -2653,11 +2742,15 @@ pub fn renameZ(old_path: [:0]const u8, new_path: [:0]const u8) RenameError!voi
2653	.NOTEMPTY => return error.PathAlreadyExists,	2742	.NOTEMPTY => return error.PathAlreadyExists,
2654	.ROFS => return error.ReadOnlyFileSystem,	2743	.ROFS => return error.ReadOnlyFileSystem,
2655	.XDEV => return error.RenameAcrossMountPoints,	2744	.XDEV => return error.RenameAcrossMountPoints,
		2745	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2746	return error.InvalidUtf8
		2747	else
		2748	return unexpectedErrno(err),
2656	else => \|err\| return unexpectedErrno(err),	2749	else => \|err\| return unexpectedErrno(err),
2657	}	2750	}
2658	}	2751	}
2659		2752
2660	/// Same as `rename` except the parameters are null-terminated UTF16LE encoded byte arrays.	2753	/// Same as `rename` except the parameters are null-terminated and WTF16LE encoded.
2661	/// Assumes target is Windows.	2754	/// Assumes target is Windows.
2662	pub fn renameW(old_path: [:0]const u16, new_path: [:0]const u16) RenameError!void {	2755	pub fn renameW(old_path: [:0]const u16, new_path: [:0]const u16) RenameError!void {
2663	const flags = windows.MOVEFILE_REPLACE_EXISTING \| windows.MOVEFILE_WRITE_THROUGH;	2756	const flags = windows.MOVEFILE_REPLACE_EXISTING \| windows.MOVEFILE_WRITE_THROUGH;
...	@@ -2665,6 +2758,9 @@ pub fn renameW(old_path: [:0]const u16, new_path: [:0]const u16) RenameError!v	...	@@ -2665,6 +2758,9 @@ pub fn renameW(old_path: [:0]const u16, new_path: [:0]const u16) RenameError!v
2665	}	2758	}
2666		2759
2667	/// Change the name or location of a file based on an open directory handle.	2760	/// Change the name or location of a file based on an open directory handle.
		2761	/// On Windows, both paths should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2762	/// On WASI, both paths should be encoded as valid UTF-8.
		2763	/// On other platforms, both paths are an opaque sequence of bytes with no particular encoding.
2668	pub fn renameat(	2764	pub fn renameat(
2669	old_dir_fd: fd_t,	2765	old_dir_fd: fd_t,
2670	old_path: []const u8,	2766	old_path: []const u8,
...	@@ -2710,11 +2806,12 @@ pub fn renameatWasi(old: RelativePathWasi, new: RelativePathWasi) RenameError!vo	...	@@ -2710,11 +2806,12 @@ pub fn renameatWasi(old: RelativePathWasi, new: RelativePathWasi) RenameError!vo
2710	.ROFS => return error.ReadOnlyFileSystem,	2806	.ROFS => return error.ReadOnlyFileSystem,
2711	.XDEV => return error.RenameAcrossMountPoints,	2807	.XDEV => return error.RenameAcrossMountPoints,
2712	.NOTCAPABLE => return error.AccessDenied,	2808	.NOTCAPABLE => return error.AccessDenied,
		2809	.ILSEQ => return error.InvalidUtf8,
2713	else => \|err\| return unexpectedErrno(err),	2810	else => \|err\| return unexpectedErrno(err),
2714	}	2811	}
2715	}	2812	}
2716		2813
2717	/// Same as `renameat` except the parameters are null-terminated byte arrays.	2814	/// Same as `renameat` except the parameters are null-terminated.
2718	pub fn renameatZ(	2815	pub fn renameatZ(
2719	old_dir_fd: fd_t,	2816	old_dir_fd: fd_t,
2720	old_path: [*:0]const u8,	2817	old_path: [*:0]const u8,
...	@@ -2749,6 +2846,10 @@ pub fn renameatZ(	...	@@ -2749,6 +2846,10 @@ pub fn renameatZ(
2749	.NOTEMPTY => return error.PathAlreadyExists,	2846	.NOTEMPTY => return error.PathAlreadyExists,
2750	.ROFS => return error.ReadOnlyFileSystem,	2847	.ROFS => return error.ReadOnlyFileSystem,
2751	.XDEV => return error.RenameAcrossMountPoints,	2848	.XDEV => return error.RenameAcrossMountPoints,
		2849	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		2850	return error.InvalidUtf8
		2851	else
		2852	return unexpectedErrno(err),
2752	else => \|err\| return unexpectedErrno(err),	2853	else => \|err\| return unexpectedErrno(err),
2753	}	2854	}
2754	}	2855	}
...	@@ -2860,6 +2961,9 @@ pub fn renameatW(	...	@@ -2860,6 +2961,9 @@ pub fn renameatW(
2860	}	2961	}
2861	}	2962	}
2862		2963
		2964	/// On Windows, `sub_dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		2965	/// On WASI, `sub_dir_path` should be encoded as valid UTF-8.
		2966	/// On other platforms, `sub_dir_path` is an opaque sequence of bytes with no particular encoding.
2863	pub fn mkdirat(dir_fd: fd_t, sub_dir_path: []const u8, mode: u32) MakeDirError!void {	2967	pub fn mkdirat(dir_fd: fd_t, sub_dir_path: []const u8, mode: u32) MakeDirError!void {
2864	if (builtin.os.tag == .windows) {	2968	if (builtin.os.tag == .windows) {
2865	const sub_dir_path_w = try windows.sliceToPrefixedFileW(dir_fd, sub_dir_path);	2969	const sub_dir_path_w = try windows.sliceToPrefixedFileW(dir_fd, sub_dir_path);
...	@@ -2891,14 +2995,16 @@ pub fn mkdiratWasi(dir_fd: fd_t, sub_dir_path: []const u8, mode: u32) MakeDirErr	...	@@ -2891,14 +2995,16 @@ pub fn mkdiratWasi(dir_fd: fd_t, sub_dir_path: []const u8, mode: u32) MakeDirErr
2891	.NOTDIR => return error.NotDir,	2995	.NOTDIR => return error.NotDir,
2892	.ROFS => return error.ReadOnlyFileSystem,	2996	.ROFS => return error.ReadOnlyFileSystem,
2893	.NOTCAPABLE => return error.AccessDenied,	2997	.NOTCAPABLE => return error.AccessDenied,
		2998	.ILSEQ => return error.InvalidUtf8,
2894	else => \|err\| return unexpectedErrno(err),	2999	else => \|err\| return unexpectedErrno(err),
2895	}	3000	}
2896	}	3001	}
2897		3002
		3003	/// Same as `mkdirat` except the parameters are null-terminated.
2898	pub fn mkdiratZ(dir_fd: fd_t, sub_dir_path: [*:0]const u8, mode: u32) MakeDirError!void {	3004	pub fn mkdiratZ(dir_fd: fd_t, sub_dir_path: [*:0]const u8, mode: u32) MakeDirError!void {
2899	if (builtin.os.tag == .windows) {	3005	if (builtin.os.tag == .windows) {
2900	const sub_dir_path_w = try windows.cStrToPrefixedFileW(dir_fd, sub_dir_path);	3006	const sub_dir_path_w = try windows.cStrToPrefixedFileW(dir_fd, sub_dir_path);
2901	return mkdiratW(dir_fd, sub_dir_path_w.span().ptr, mode);	3007	return mkdiratW(dir_fd, sub_dir_path_w.span(), mode);
2902	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	3008	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
2903	return mkdirat(dir_fd, mem.sliceTo(sub_dir_path, 0), mode);	3009	return mkdirat(dir_fd, mem.sliceTo(sub_dir_path, 0), mode);
2904	}	3010	}
...	@@ -2920,10 +3026,15 @@ pub fn mkdiratZ(dir_fd: fd_t, sub_dir_path: [*:0]const u8, mode: u32) MakeDirErr	...	@@ -2920,10 +3026,15 @@ pub fn mkdiratZ(dir_fd: fd_t, sub_dir_path: [*:0]const u8, mode: u32) MakeDirErr
2920	.ROFS => return error.ReadOnlyFileSystem,	3026	.ROFS => return error.ReadOnlyFileSystem,
2921	// dragonfly: when dir_fd is unlinked from filesystem	3027	// dragonfly: when dir_fd is unlinked from filesystem
2922	.NOTCONN => return error.FileNotFound,	3028	.NOTCONN => return error.FileNotFound,
		3029	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3030	return error.InvalidUtf8
		3031	else
		3032	return unexpectedErrno(err),
2923	else => \|err\| return unexpectedErrno(err),	3033	else => \|err\| return unexpectedErrno(err),
2924	}	3034	}
2925	}	3035	}
2926		3036
		3037	/// Windows-only. Same as `mkdirat` except the parameter WTF16 LE encoded.
2927	pub fn mkdiratW(dir_fd: fd_t, sub_path_w: []const u16, mode: u32) MakeDirError!void {	3038	pub fn mkdiratW(dir_fd: fd_t, sub_path_w: []const u16, mode: u32) MakeDirError!void {
2928	_ = mode;	3039	_ = mode;
2929	const sub_dir_handle = windows.OpenFile(sub_path_w, .{	3040	const sub_dir_handle = windows.OpenFile(sub_path_w, .{
...	@@ -2955,7 +3066,11 @@ pub const MakeDirError = error{	...	@@ -2955,7 +3066,11 @@ pub const MakeDirError = error{
2955	NoSpaceLeft,	3066	NoSpaceLeft,
2956	NotDir,	3067	NotDir,
2957	ReadOnlyFileSystem,	3068	ReadOnlyFileSystem,
		3069	/// WASI-only; file paths must be valid UTF-8.
2958	InvalidUtf8,	3070	InvalidUtf8,
		3071	/// Windows-only; file paths provided by the user must be valid WTF-8.
		3072	/// https://simonsapin.github.io/wtf-8/
		3073	InvalidWtf8,
2959	BadPathName,	3074	BadPathName,
2960	NoDevice,	3075	NoDevice,
2961	/// On Windows, `\\server` or `\\server\share` was not found.	3076	/// On Windows, `\\server` or `\\server\share` was not found.
...	@@ -2964,6 +3079,9 @@ pub const MakeDirError = error{	...	@@ -2964,6 +3079,9 @@ pub const MakeDirError = error{
2964		3079
2965	/// Create a directory.	3080	/// Create a directory.
2966	/// `mode` is ignored on Windows and WASI.	3081	/// `mode` is ignored on Windows and WASI.
		3082	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3083	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3084	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
2967	pub fn mkdir(dir_path: []const u8, mode: u32) MakeDirError!void {	3085	pub fn mkdir(dir_path: []const u8, mode: u32) MakeDirError!void {
2968	if (builtin.os.tag == .wasi and !builtin.link_libc) {	3086	if (builtin.os.tag == .wasi and !builtin.link_libc) {
2969	return mkdirat(wasi.AT.FDCWD, dir_path, mode);	3087	return mkdirat(wasi.AT.FDCWD, dir_path, mode);
...	@@ -2976,7 +3094,10 @@ pub fn mkdir(dir_path: []const u8, mode: u32) MakeDirError!void {	...	@@ -2976,7 +3094,10 @@ pub fn mkdir(dir_path: []const u8, mode: u32) MakeDirError!void {
2976	}	3094	}
2977	}	3095	}
2978		3096
2979	/// Same as `mkdir` but the parameter is a null-terminated UTF8-encoded string.	3097	/// Same as `mkdir` but the parameter is null-terminated.
		3098	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3099	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3100	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
2980	pub fn mkdirZ(dir_path: [*:0]const u8, mode: u32) MakeDirError!void {	3101	pub fn mkdirZ(dir_path: [*:0]const u8, mode: u32) MakeDirError!void {
2981	if (builtin.os.tag == .windows) {	3102	if (builtin.os.tag == .windows) {
2982	const dir_path_w = try windows.cStrToPrefixedFileW(null, dir_path);	3103	const dir_path_w = try windows.cStrToPrefixedFileW(null, dir_path);
...	@@ -2999,11 +3120,15 @@ pub fn mkdirZ(dir_path: [*:0]const u8, mode: u32) MakeDirError!void {	...	@@ -2999,11 +3120,15 @@ pub fn mkdirZ(dir_path: [*:0]const u8, mode: u32) MakeDirError!void {
2999	.NOSPC => return error.NoSpaceLeft,	3120	.NOSPC => return error.NoSpaceLeft,
3000	.NOTDIR => return error.NotDir,	3121	.NOTDIR => return error.NotDir,
3001	.ROFS => return error.ReadOnlyFileSystem,	3122	.ROFS => return error.ReadOnlyFileSystem,
		3123	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3124	return error.InvalidUtf8
		3125	else
		3126	return unexpectedErrno(err),
3002	else => \|err\| return unexpectedErrno(err),	3127	else => \|err\| return unexpectedErrno(err),
3003	}	3128	}
3004	}	3129	}
3005		3130
3006	/// Windows-only. Same as `mkdir` but the parameters is WTF16 encoded.	3131	/// Windows-only. Same as `mkdir` but the parameters is WTF16LE encoded.
3007	pub fn mkdirW(dir_path_w: []const u16, mode: u32) MakeDirError!void {	3132	pub fn mkdirW(dir_path_w: []const u16, mode: u32) MakeDirError!void {
3008	_ = mode;	3133	_ = mode;
3009	const sub_dir_handle = windows.OpenFile(dir_path_w, .{	3134	const sub_dir_handle = windows.OpenFile(dir_path_w, .{
...	@@ -3031,13 +3156,20 @@ pub const DeleteDirError = error{	...	@@ -3031,13 +3156,20 @@ pub const DeleteDirError = error{
3031	NotDir,	3156	NotDir,
3032	DirNotEmpty,	3157	DirNotEmpty,
3033	ReadOnlyFileSystem,	3158	ReadOnlyFileSystem,
		3159	/// WASI-only; file paths must be valid UTF-8.
3034	InvalidUtf8,	3160	InvalidUtf8,
		3161	/// Windows-only; file paths provided by the user must be valid WTF-8.
		3162	/// https://simonsapin.github.io/wtf-8/
		3163	InvalidWtf8,
3035	BadPathName,	3164	BadPathName,
3036	/// On Windows, `\\server` or `\\server\share` was not found.	3165	/// On Windows, `\\server` or `\\server\share` was not found.
3037	NetworkNotFound,	3166	NetworkNotFound,
3038	} \|\| UnexpectedError;	3167	} \|\| UnexpectedError;
3039		3168
3040	/// Deletes an empty directory.	3169	/// Deletes an empty directory.
		3170	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3171	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3172	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
3041	pub fn rmdir(dir_path: []const u8) DeleteDirError!void {	3173	pub fn rmdir(dir_path: []const u8) DeleteDirError!void {
3042	if (builtin.os.tag == .wasi and !builtin.link_libc) {	3174	if (builtin.os.tag == .wasi and !builtin.link_libc) {
3043	return unlinkat(wasi.AT.FDCWD, dir_path, AT.REMOVEDIR) catch \|err\| switch (err) {	3175	return unlinkat(wasi.AT.FDCWD, dir_path, AT.REMOVEDIR) catch \|err\| switch (err) {
...	@@ -3055,6 +3187,9 @@ pub fn rmdir(dir_path: []const u8) DeleteDirError!void {	...	@@ -3055,6 +3187,9 @@ pub fn rmdir(dir_path: []const u8) DeleteDirError!void {
3055	}	3187	}
3056		3188
3057	/// Same as `rmdir` except the parameter is null-terminated.	3189	/// Same as `rmdir` except the parameter is null-terminated.
		3190	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3191	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3192	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
3058	pub fn rmdirZ(dir_path: [*:0]const u8) DeleteDirError!void {	3193	pub fn rmdirZ(dir_path: [*:0]const u8) DeleteDirError!void {
3059	if (builtin.os.tag == .windows) {	3194	if (builtin.os.tag == .windows) {
3060	const dir_path_w = try windows.cStrToPrefixedFileW(null, dir_path);	3195	const dir_path_w = try windows.cStrToPrefixedFileW(null, dir_path);
...	@@ -3077,11 +3212,15 @@ pub fn rmdirZ(dir_path: [*:0]const u8) DeleteDirError!void {	...	@@ -3077,11 +3212,15 @@ pub fn rmdirZ(dir_path: [*:0]const u8) DeleteDirError!void {
3077	.EXIST => return error.DirNotEmpty,	3212	.EXIST => return error.DirNotEmpty,
3078	.NOTEMPTY => return error.DirNotEmpty,	3213	.NOTEMPTY => return error.DirNotEmpty,
3079	.ROFS => return error.ReadOnlyFileSystem,	3214	.ROFS => return error.ReadOnlyFileSystem,
		3215	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3216	return error.InvalidUtf8
		3217	else
		3218	return unexpectedErrno(err),
3080	else => \|err\| return unexpectedErrno(err),	3219	else => \|err\| return unexpectedErrno(err),
3081	}	3220	}
3082	}	3221	}
3083		3222
3084	/// Windows-only. Same as `rmdir` except the parameter is WTF16 encoded.	3223	/// Windows-only. Same as `rmdir` except the parameter is WTF-16 LE encoded.
3085	pub fn rmdirW(dir_path_w: []const u16) DeleteDirError!void {	3224	pub fn rmdirW(dir_path_w: []const u16) DeleteDirError!void {
3086	return windows.DeleteFile(dir_path_w, .{ .dir = std.fs.cwd().fd, .remove_dir = true }) catch \|err\| switch (err) {	3225	return windows.DeleteFile(dir_path_w, .{ .dir = std.fs.cwd().fd, .remove_dir = true }) catch \|err\| switch (err) {
3087	error.IsDir => unreachable,	3226	error.IsDir => unreachable,
...	@@ -3098,21 +3237,25 @@ pub const ChangeCurDirError = error{	...	@@ -3098,21 +3237,25 @@ pub const ChangeCurDirError = error{
3098	SystemResources,	3237	SystemResources,
3099	NotDir,	3238	NotDir,
3100	BadPathName,	3239	BadPathName,
3101		3240	/// WASI-only; file paths must be valid UTF-8.
3102	/// On Windows, file paths must be valid Unicode.
3103	InvalidUtf8,	3241	InvalidUtf8,
		3242	/// Windows-only; file paths provided by the user must be valid WTF-8.
		3243	/// https://simonsapin.github.io/wtf-8/
		3244	InvalidWtf8,
3104	} \|\| UnexpectedError;	3245	} \|\| UnexpectedError;
3105		3246
3106	/// Changes the current working directory of the calling process.	3247	/// Changes the current working directory of the calling process.
3107	/// `dir_path` is recommended to be a UTF-8 encoded string.	3248	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3249	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3250	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
3108	pub fn chdir(dir_path: []const u8) ChangeCurDirError!void {	3251	pub fn chdir(dir_path: []const u8) ChangeCurDirError!void {
3109	if (builtin.os.tag == .wasi and !builtin.link_libc) {	3252	if (builtin.os.tag == .wasi and !builtin.link_libc) {
3110	@compileError("WASI does not support os.chdir");	3253	@compileError("WASI does not support os.chdir");
3111	} else if (builtin.os.tag == .windows) {	3254	} else if (builtin.os.tag == .windows) {
3112	var utf16_dir_path: [windows.PATH_MAX_WIDE]u16 = undefined;	3255	var wtf16_dir_path: [windows.PATH_MAX_WIDE]u16 = undefined;
3113	const len = try std.unicode.utf8ToUtf16Le(utf16_dir_path[0..], dir_path);	3256	const len = try std.unicode.wtf8ToWtf16Le(wtf16_dir_path[0..], dir_path);
3114	if (len > utf16_dir_path.len) return error.NameTooLong;	3257	if (len > wtf16_dir_path.len) return error.NameTooLong;
3115	return chdirW(utf16_dir_path[0..len]);	3258	return chdirW(wtf16_dir_path[0..len]);
3116	} else {	3259	} else {
3117	const dir_path_c = try toPosixPath(dir_path);	3260	const dir_path_c = try toPosixPath(dir_path);
3118	return chdirZ(&dir_path_c);	3261	return chdirZ(&dir_path_c);
...	@@ -3120,12 +3263,15 @@ pub fn chdir(dir_path: []const u8) ChangeCurDirError!void {	...	@@ -3120,12 +3263,15 @@ pub fn chdir(dir_path: []const u8) ChangeCurDirError!void {
3120	}	3263	}
3121		3264
3122	/// Same as `chdir` except the parameter is null-terminated.	3265	/// Same as `chdir` except the parameter is null-terminated.
		3266	/// On Windows, `dir_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3267	/// On WASI, `dir_path` should be encoded as valid UTF-8.
		3268	/// On other platforms, `dir_path` is an opaque sequence of bytes with no particular encoding.
3123	pub fn chdirZ(dir_path: [*:0]const u8) ChangeCurDirError!void {	3269	pub fn chdirZ(dir_path: [*:0]const u8) ChangeCurDirError!void {
3124	if (builtin.os.tag == .windows) {	3270	if (builtin.os.tag == .windows) {
3125	var utf16_dir_path: [windows.PATH_MAX_WIDE]u16 = undefined;	3271	var wtf16_dir_path: [windows.PATH_MAX_WIDE]u16 = undefined;
3126	const len = try std.unicode.utf8ToUtf16Le(utf16_dir_path[0..], mem.span(dir_path));	3272	const len = try std.unicode.wtf8ToWtf16Le(wtf16_dir_path[0..], mem.span(dir_path));
3127	if (len > utf16_dir_path.len) return error.NameTooLong;	3273	if (len > wtf16_dir_path.len) return error.NameTooLong;
3128	return chdirW(utf16_dir_path[0..len]);	3274	return chdirW(wtf16_dir_path[0..len]);
3129	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	3275	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
3130	return chdir(mem.span(dir_path));	3276	return chdir(mem.span(dir_path));
3131	}	3277	}
...	@@ -3139,11 +3285,15 @@ pub fn chdirZ(dir_path: [*:0]const u8) ChangeCurDirError!void {	...	@@ -3139,11 +3285,15 @@ pub fn chdirZ(dir_path: [*:0]const u8) ChangeCurDirError!void {
3139	.NOENT => return error.FileNotFound,	3285	.NOENT => return error.FileNotFound,
3140	.NOMEM => return error.SystemResources,	3286	.NOMEM => return error.SystemResources,
3141	.NOTDIR => return error.NotDir,	3287	.NOTDIR => return error.NotDir,
		3288	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3289	return error.InvalidUtf8
		3290	else
		3291	return unexpectedErrno(err),
3142	else => \|err\| return unexpectedErrno(err),	3292	else => \|err\| return unexpectedErrno(err),
3143	}	3293	}
3144	}	3294	}
3145		3295
3146	/// Windows-only. Same as `chdir` except the parameter is WTF16 encoded.	3296	/// Windows-only. Same as `chdir` except the parameter is WTF16 LE encoded.
3147	pub fn chdirW(dir_path: []const u16) ChangeCurDirError!void {	3297	pub fn chdirW(dir_path: []const u16) ChangeCurDirError!void {
3148	windows.SetCurrentDirectory(dir_path) catch \|err\| switch (err) {	3298	windows.SetCurrentDirectory(dir_path) catch \|err\| switch (err) {
3149	error.NoDevice => return error.FileSystem,	3299	error.NoDevice => return error.FileSystem,
...	@@ -3183,7 +3333,11 @@ pub const ReadLinkError = error{	...	@@ -3183,7 +3333,11 @@ pub const ReadLinkError = error{
3183	SystemResources,	3333	SystemResources,
3184	NotLink,	3334	NotLink,
3185	NotDir,	3335	NotDir,
		3336	/// WASI-only; file paths must be valid UTF-8.
3186	InvalidUtf8,	3337	InvalidUtf8,
		3338	/// Windows-only; file paths provided by the user must be valid WTF-8.
		3339	/// https://simonsapin.github.io/wtf-8/
		3340	InvalidWtf8,
3187	BadPathName,	3341	BadPathName,
3188	/// Windows-only. This error may occur if the opened reparse point is	3342	/// Windows-only. This error may occur if the opened reparse point is
3189	/// of unsupported type.	3343	/// of unsupported type.
...	@@ -3193,7 +3347,13 @@ pub const ReadLinkError = error{	...	@@ -3193,7 +3347,13 @@ pub const ReadLinkError = error{
3193	} \|\| UnexpectedError;	3347	} \|\| UnexpectedError;
3194		3348
3195	/// Read value of a symbolic link.	3349	/// Read value of a symbolic link.
		3350	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3351	/// On WASI, `file_path` should be encoded as valid UTF-8.
		3352	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
3196	/// The return value is a slice of `out_buffer` from index 0.	3353	/// The return value is a slice of `out_buffer` from index 0.
		3354	/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3355	/// On WASI, the result is encoded as UTF-8.
		3356	/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
3197	pub fn readlink(file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {	3357	pub fn readlink(file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {
3198	if (builtin.os.tag == .wasi and !builtin.link_libc) {	3358	if (builtin.os.tag == .wasi and !builtin.link_libc) {
3199	return readlinkat(wasi.AT.FDCWD, file_path, out_buffer);	3359	return readlinkat(wasi.AT.FDCWD, file_path, out_buffer);
...	@@ -3206,7 +3366,8 @@ pub fn readlink(file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {	...	@@ -3206,7 +3366,8 @@ pub fn readlink(file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {
3206	}	3366	}
3207	}	3367	}
3208		3368
3209	/// Windows-only. Same as `readlink` except `file_path` is WTF16 encoded.	3369	/// Windows-only. Same as `readlink` except `file_path` is WTF16 LE encoded.
		3370	/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
3210	/// See also `readlinkZ`.	3371	/// See also `readlinkZ`.
3211	pub fn readlinkW(file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {	3372	pub fn readlinkW(file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {
3212	return windows.ReadLink(std.fs.cwd().fd, file_path, out_buffer);	3373	return windows.ReadLink(std.fs.cwd().fd, file_path, out_buffer);
...	@@ -3215,7 +3376,7 @@ pub fn readlinkW(file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {	...	@@ -3215,7 +3376,7 @@ pub fn readlinkW(file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {
3215	/// Same as `readlink` except `file_path` is null-terminated.	3376	/// Same as `readlink` except `file_path` is null-terminated.
3216	pub fn readlinkZ(file_path: [*:0]const u8, out_buffer: []u8) ReadLinkError![]u8 {	3377	pub fn readlinkZ(file_path: [*:0]const u8, out_buffer: []u8) ReadLinkError![]u8 {
3217	if (builtin.os.tag == .windows) {	3378	if (builtin.os.tag == .windows) {
3218	const file_path_w = try windows.cStrToWin32PrefixedFileW(file_path);	3379	const file_path_w = try windows.cStrToPrefixedFileW(null, file_path);
3219	return readlinkW(file_path_w.span(), out_buffer);	3380	return readlinkW(file_path_w.span(), out_buffer);
3220	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {	3381	} else if (builtin.os.tag == .wasi and !builtin.link_libc) {
3221	return readlink(mem.sliceTo(file_path, 0), out_buffer);	3382	return readlink(mem.sliceTo(file_path, 0), out_buffer);
...	@@ -3232,12 +3393,22 @@ pub fn readlinkZ(file_path: [*:0]const u8, out_buffer: []u8) ReadLinkError![]u8	...	@@ -3232,12 +3393,22 @@ pub fn readlinkZ(file_path: [*:0]const u8, out_buffer: []u8) ReadLinkError![]u8
3232	.NOENT => return error.FileNotFound,	3393	.NOENT => return error.FileNotFound,
3233	.NOMEM => return error.SystemResources,	3394	.NOMEM => return error.SystemResources,
3234	.NOTDIR => return error.NotDir,	3395	.NOTDIR => return error.NotDir,
		3396	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3397	return error.InvalidUtf8
		3398	else
		3399	return unexpectedErrno(err),
3235	else => \|err\| return unexpectedErrno(err),	3400	else => \|err\| return unexpectedErrno(err),
3236	}	3401	}
3237	}	3402	}
3238		3403
3239	/// Similar to `readlink` except reads value of a symbolink link relative to `dirfd` directory handle.	3404	/// Similar to `readlink` except reads value of a symbolink link relative to `dirfd` directory handle.
		3405	/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3406	/// On WASI, `file_path` should be encoded as valid UTF-8.
		3407	/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
3240	/// The return value is a slice of `out_buffer` from index 0.	3408	/// The return value is a slice of `out_buffer` from index 0.
		3409	/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		3410	/// On WASI, the result is encoded as UTF-8.
		3411	/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
3241	/// See also `readlinkatWasi`, `realinkatZ` and `realinkatW`.	3412	/// See also `readlinkatWasi`, `realinkatZ` and `realinkatW`.
3242	pub fn readlinkat(dirfd: fd_t, file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {	3413	pub fn readlinkat(dirfd: fd_t, file_path: []const u8, out_buffer: []u8) ReadLinkError![]u8 {
3243	if (builtin.os.tag == .wasi and !builtin.link_libc) {	3414	if (builtin.os.tag == .wasi and !builtin.link_libc) {
...	@@ -3267,11 +3438,13 @@ pub fn readlinkatWasi(dirfd: fd_t, file_path: []const u8, out_buffer: []u8) Read	...	@@ -3267,11 +3438,13 @@ pub fn readlinkatWasi(dirfd: fd_t, file_path: []const u8, out_buffer: []u8) Read
3267	.NOMEM => return error.SystemResources,	3438	.NOMEM => return error.SystemResources,
3268	.NOTDIR => return error.NotDir,	3439	.NOTDIR => return error.NotDir,
3269	.NOTCAPABLE => return error.AccessDenied,	3440	.NOTCAPABLE => return error.AccessDenied,
		3441	.ILSEQ => return error.InvalidUtf8,
3270	else => \|err\| return unexpectedErrno(err),	3442	else => \|err\| return unexpectedErrno(err),
3271	}	3443	}
3272	}	3444	}
3273		3445
3274	/// Windows-only. Same as `readlinkat` except `file_path` is null-terminated, WTF16 encoded.	3446	/// Windows-only. Same as `readlinkat` except `file_path` is null-terminated, WTF16 LE encoded.
		3447	/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
3275	/// See also `readlinkat`.	3448	/// See also `readlinkat`.
3276	pub fn readlinkatW(dirfd: fd_t, file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {	3449	pub fn readlinkatW(dirfd: fd_t, file_path: []const u16, out_buffer: []u8) ReadLinkError![]u8 {
3277	return windows.ReadLink(dirfd, file_path, out_buffer);	3450	return windows.ReadLink(dirfd, file_path, out_buffer);
...	@@ -3298,6 +3471,10 @@ pub fn readlinkatZ(dirfd: fd_t, file_path: [*:0]const u8, out_buffer: []u8) Read	...	@@ -3298,6 +3471,10 @@ pub fn readlinkatZ(dirfd: fd_t, file_path: [*:0]const u8, out_buffer: []u8) Read
3298	.NOENT => return error.FileNotFound,	3471	.NOENT => return error.FileNotFound,
3299	.NOMEM => return error.SystemResources,	3472	.NOMEM => return error.SystemResources,
3300	.NOTDIR => return error.NotDir,	3473	.NOTDIR => return error.NotDir,
		3474	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		3475	return error.InvalidUtf8
		3476	else
		3477	return unexpectedErrno(err),
3301	else => \|err\| return unexpectedErrno(err),	3478	else => \|err\| return unexpectedErrno(err),
3302	}	3479	}
3303	}	3480	}
...	@@ -4274,10 +4451,18 @@ pub fn fstat_wasi(fd: fd_t) FStatError!wasi.filestat_t {	...	@@ -4274,10 +4451,18 @@ pub fn fstat_wasi(fd: fd_t) FStatError!wasi.filestat_t {
4274	}	4451	}
4275	}	4452	}
4276		4453
4277	pub const FStatAtError = FStatError \|\| error{ NameTooLong, FileNotFound, SymLinkLoop };	4454	pub const FStatAtError = FStatError \|\| error{
		4455	NameTooLong,
		4456	FileNotFound,
		4457	SymLinkLoop,
		4458	/// WASI-only; file paths must be valid UTF-8.
		4459	InvalidUtf8,
		4460	};
4278		4461
4279	/// Similar to `fstat`, but returns stat of a resource pointed to by `pathname`	4462	/// Similar to `fstat`, but returns stat of a resource pointed to by `pathname`
4280	/// which is relative to `dirfd` handle.	4463	/// which is relative to `dirfd` handle.
		4464	/// On WASI, `pathname` should be encoded as valid UTF-8.
		4465	/// On other platforms, `pathname` is an opaque sequence of bytes with no particular encoding.
4281	/// See also `fstatatZ` and `fstatat_wasi`.	4466	/// See also `fstatatZ` and `fstatat_wasi`.
4282	pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat {	4467	pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat {
4283	if (builtin.os.tag == .wasi and !builtin.link_libc) {	4468	if (builtin.os.tag == .wasi and !builtin.link_libc) {
...	@@ -4294,6 +4479,7 @@ pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat	...	@@ -4294,6 +4479,7 @@ pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat
4294	}	4479	}
4295		4480
4296	/// WASI-only. Same as `fstatat` but targeting WASI.	4481	/// WASI-only. Same as `fstatat` but targeting WASI.
		4482	/// `pathname` should be encoded as valid UTF-8.
4297	/// See also `fstatat`.	4483	/// See also `fstatat`.
4298	pub fn fstatat_wasi(dirfd: fd_t, pathname: []const u8, flags: wasi.lookupflags_t) FStatAtError!wasi.filestat_t {	4484	pub fn fstatat_wasi(dirfd: fd_t, pathname: []const u8, flags: wasi.lookupflags_t) FStatAtError!wasi.filestat_t {
4299	var stat: wasi.filestat_t = undefined;	4485	var stat: wasi.filestat_t = undefined;
...	@@ -4308,6 +4494,7 @@ pub fn fstatat_wasi(dirfd: fd_t, pathname: []const u8, flags: wasi.lookupflags_t	...	@@ -4308,6 +4494,7 @@ pub fn fstatat_wasi(dirfd: fd_t, pathname: []const u8, flags: wasi.lookupflags_t
4308	.NOENT => return error.FileNotFound,	4494	.NOENT => return error.FileNotFound,
4309	.NOTDIR => return error.FileNotFound,	4495	.NOTDIR => return error.FileNotFound,
4310	.NOTCAPABLE => return error.AccessDenied,	4496	.NOTCAPABLE => return error.AccessDenied,
		4497	.ILSEQ => return error.InvalidUtf8,
4311	else => \|err\| return unexpectedErrno(err),	4498	else => \|err\| return unexpectedErrno(err),
4312	}	4499	}
4313	}	4500	}
...	@@ -4337,6 +4524,10 @@ pub fn fstatatZ(dirfd: fd_t, pathname: [*:0]const u8, flags: u32) FStatAtError!S	...	@@ -4337,6 +4524,10 @@ pub fn fstatatZ(dirfd: fd_t, pathname: [*:0]const u8, flags: u32) FStatAtError!S
4337	.LOOP => return error.SymLinkLoop,	4524	.LOOP => return error.SymLinkLoop,
4338	.NOENT => return error.FileNotFound,	4525	.NOENT => return error.FileNotFound,
4339	.NOTDIR => return error.FileNotFound,	4526	.NOTDIR => return error.FileNotFound,
		4527	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		4528	return error.InvalidUtf8
		4529	else
		4530	return unexpectedErrno(err),
4340	else => \|err\| return unexpectedErrno(err),	4531	else => \|err\| return unexpectedErrno(err),
4341	}	4532	}
4342	}	4533	}
...	@@ -4693,12 +4884,17 @@ pub const AccessError = error{	...	@@ -4693,12 +4884,17 @@ pub const AccessError = error{
4693	FileBusy,	4884	FileBusy,
4694	SymLinkLoop,	4885	SymLinkLoop,
4695	ReadOnlyFileSystem,	4886	ReadOnlyFileSystem,
4696		4887	/// WASI-only; file paths must be valid UTF-8.
4697	/// On Windows, file paths must be valid Unicode.
4698	InvalidUtf8,	4888	InvalidUtf8,
		4889	/// Windows-only; file paths provided by the user must be valid WTF-8.
		4890	/// https://simonsapin.github.io/wtf-8/
		4891	InvalidWtf8,
4699	} \|\| UnexpectedError;	4892	} \|\| UnexpectedError;
4700		4893
4701	/// check user's permissions for a file	4894	/// check user's permissions for a file
		4895	/// On Windows, `path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		4896	/// On WASI, `path` should be encoded as valid UTF-8.
		4897	/// On other platforms, `path` is an opaque sequence of bytes with no particular encoding.
4702	/// TODO currently this assumes `mode` is `F.OK` on Windows.	4898	/// TODO currently this assumes `mode` is `F.OK` on Windows.
4703	pub fn access(path: []const u8, mode: u32) AccessError!void {	4899	pub fn access(path: []const u8, mode: u32) AccessError!void {
4704	if (builtin.os.tag == .windows) {	4900	if (builtin.os.tag == .windows) {
...	@@ -4740,12 +4936,16 @@ pub fn accessZ(path: [*:0]const u8, mode: u32) AccessError!void {	...	@@ -4740,12 +4936,16 @@ pub fn accessZ(path: [*:0]const u8, mode: u32) AccessError!void {
4740	.FAULT => unreachable,	4936	.FAULT => unreachable,
4741	.IO => return error.InputOutput,	4937	.IO => return error.InputOutput,
4742	.NOMEM => return error.SystemResources,	4938	.NOMEM => return error.SystemResources,
		4939	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		4940	return error.InvalidUtf8
		4941	else
		4942	return unexpectedErrno(err),
4743	else => \|err\| return unexpectedErrno(err),	4943	else => \|err\| return unexpectedErrno(err),
4744	}	4944	}
4745	}	4945	}
4746		4946
4747	/// Call from Windows-specific code if you already have a UTF-16LE encoded, null terminated string.	4947	/// Call from Windows-specific code if you already have a WTF-16LE encoded, null terminated string.
4748	/// Otherwise use `access` or `accessC`.	4948	/// Otherwise use `access` or `accessZ`.
4749	/// TODO currently this ignores `mode`.	4949	/// TODO currently this ignores `mode`.
4750	pub fn accessW(path: [*:0]const u16, mode: u32) windows.GetFileAttributesError!void {	4950	pub fn accessW(path: [*:0]const u16, mode: u32) windows.GetFileAttributesError!void {
4751	_ = mode;	4951	_ = mode;
...	@@ -4762,6 +4962,9 @@ pub fn accessW(path: [*:0]const u16, mode: u32) windows.GetFileAttributesError!v	...	@@ -4762,6 +4962,9 @@ pub fn accessW(path: [*:0]const u16, mode: u32) windows.GetFileAttributesError!v
4762	}	4962	}
4763		4963
4764	/// Check user's permissions for a file, based on an open directory handle.	4964	/// Check user's permissions for a file, based on an open directory handle.
		4965	/// On Windows, `path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		4966	/// On WASI, `path` should be encoded as valid UTF-8.
		4967	/// On other platforms, `path` is an opaque sequence of bytes with no particular encoding.
4765	/// TODO currently this ignores `mode` and `flags` on Windows.	4968	/// TODO currently this ignores `mode` and `flags` on Windows.
4766	pub fn faccessat(dirfd: fd_t, path: []const u8, mode: u32, flags: u32) AccessError!void {	4969	pub fn faccessat(dirfd: fd_t, path: []const u8, mode: u32, flags: u32) AccessError!void {
4767	if (builtin.os.tag == .windows) {	4970	if (builtin.os.tag == .windows) {
...	@@ -4832,6 +5035,10 @@ pub fn faccessatZ(dirfd: fd_t, path: [*:0]const u8, mode: u32, flags: u32) Acces	...	@@ -4832,6 +5035,10 @@ pub fn faccessatZ(dirfd: fd_t, path: [*:0]const u8, mode: u32, flags: u32) Acces
4832	.FAULT => unreachable,	5035	.FAULT => unreachable,
4833	.IO => return error.InputOutput,	5036	.IO => return error.InputOutput,
4834	.NOMEM => return error.SystemResources,	5037	.NOMEM => return error.SystemResources,
		5038	.ILSEQ => \|err\| if (builtin.os.tag == .wasi)
		5039	return error.InvalidUtf8
		5040	else
		5041	return unexpectedErrno(err),
4835	else => \|err\| return unexpectedErrno(err),	5042	else => \|err\| return unexpectedErrno(err),
4836	}	5043	}
4837	}	5044	}
...	@@ -5339,8 +5546,9 @@ pub const RealPathError = error{	...	@@ -5339,8 +5546,9 @@ pub const RealPathError = error{
5339	/// On WASI, the current CWD may not be associated with an absolute path.	5546	/// On WASI, the current CWD may not be associated with an absolute path.
5340	InvalidHandle,	5547	InvalidHandle,
5341		5548
5342	/// On Windows, file paths must be valid Unicode.	5549	/// Windows-only; file paths provided by the user must be valid WTF-8.
5343	InvalidUtf8,	5550	/// https://simonsapin.github.io/wtf-8/
		5551	InvalidWtf8,
5344		5552
5345	/// On Windows, `\\server` or `\\server\share` was not found.	5553	/// On Windows, `\\server` or `\\server\share` was not found.
5346	NetworkNotFound,	5554	NetworkNotFound,
...	@@ -5362,8 +5570,12 @@ pub const RealPathError = error{	...	@@ -5362,8 +5570,12 @@ pub const RealPathError = error{
5362	/// Return the canonicalized absolute pathname.	5570	/// Return the canonicalized absolute pathname.
5363	/// Expands all symbolic links and resolves references to `.`, `..`, and	5571	/// Expands all symbolic links and resolves references to `.`, `..`, and
5364	/// extra `/` characters in `pathname`.	5572	/// extra `/` characters in `pathname`.
		5573	/// On Windows, `pathname` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		5574	/// On other platforms, `pathname` is an opaque sequence of bytes with no particular encoding.
5365	/// The return value is a slice of `out_buffer`, but not necessarily from the beginning.	5575	/// The return value is a slice of `out_buffer`, but not necessarily from the beginning.
5366	/// See also `realpathZ` and `realpathW`.	5576	/// See also `realpathZ` and `realpathW`.
		5577	/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		5578	/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
5367	/// Calling this function is usually a bug.	5579	/// Calling this function is usually a bug.
5368	pub fn realpath(pathname: []const u8, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {	5580	pub fn realpath(pathname: []const u8, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5369	if (builtin.os.tag == .windows) {	5581	if (builtin.os.tag == .windows) {
...	@@ -5402,6 +5614,7 @@ pub fn realpathZ(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP	...	@@ -5402,6 +5614,7 @@ pub fn realpathZ(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP
5402	error.WouldBlock => unreachable,	5614	error.WouldBlock => unreachable,
5403	error.FileBusy => unreachable, // not asking for write permissions	5615	error.FileBusy => unreachable, // not asking for write permissions
5404	error.InvalidHandle => unreachable, // WASI-only	5616	error.InvalidHandle => unreachable, // WASI-only
		5617	error.InvalidUtf8 => unreachable, // WASI-only
5405	else => \|e\| return e,	5618	else => \|e\| return e,
5406	};	5619	};
5407	defer close(fd);	5620	defer close(fd);
...	@@ -5425,7 +5638,8 @@ pub fn realpathZ(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP	...	@@ -5425,7 +5638,8 @@ pub fn realpathZ(pathname: [:0]const u8, out_buffer: [MAX_PATH_BYTES]u8) RealP
5425	return mem.sliceTo(result_path, 0);	5638	return mem.sliceTo(result_path, 0);
5426	}	5639	}
5427		5640
5428	/// Same as `realpath` except `pathname` is UTF16LE-encoded.	5641	/// Same as `realpath` except `pathname` is WTF16LE-encoded.
		5642	/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
5429	/// Calling this function is usually a bug.	5643	/// Calling this function is usually a bug.
5430	pub fn realpathW(pathname: []const u16, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {	5644	pub fn realpathW(pathname: []const u16, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5431	const w = windows;	5645	const w = windows;
...	@@ -5475,6 +5689,8 @@ pub fn isGetFdPathSupportedOnTarget(os: std.Target.Os) bool {	...	@@ -5475,6 +5689,8 @@ pub fn isGetFdPathSupportedOnTarget(os: std.Target.Os) bool {
5475	/// This function is very host-specific and is not universally supported by all hosts.	5689	/// This function is very host-specific and is not universally supported by all hosts.
5476	/// For example, while it generally works on Linux, macOS, FreeBSD or Windows, it is	5690	/// For example, while it generally works on Linux, macOS, FreeBSD or Windows, it is
5477	/// unsupported on WASI.	5691	/// unsupported on WASI.
		5692	/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
		5693	/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
5478	/// Calling this function is usually a bug.	5694	/// Calling this function is usually a bug.
5479	pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {	5695	pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5480	if (!comptime isGetFdPathSupportedOnTarget(builtin.os)) {	5696	if (!comptime isGetFdPathSupportedOnTarget(builtin.os)) {
...	@@ -5485,10 +5701,7 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {	...	@@ -5485,10 +5701,7 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5485	var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;	5701	var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
5486	const wide_slice = try windows.GetFinalPathNameByHandle(fd, .{}, wide_buf[0..]);	5702	const wide_slice = try windows.GetFinalPathNameByHandle(fd, .{}, wide_buf[0..]);
5487		5703
5488	// TODO: Windows file paths can be arbitrary arrays of u16 values	5704	const end_index = std.unicode.wtf16LeToWtf8(out_buffer, wide_slice);
5489	// and must not fail with InvalidUtf8.
5490	const end_index = std.unicode.utf16leToUtf8(out_buffer, wide_slice) catch
5491	return error.InvalidUtf8;
5492	return out_buffer[0..end_index];	5705	return out_buffer[0..end_index];
5493	},	5706	},
5494	.macos, .ios, .watchos, .tvos => {	5707	.macos, .ios, .watchos, .tvos => {
...	@@ -5512,8 +5725,12 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {	...	@@ -5512,8 +5725,12 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5512		5725
5513	const target = readlinkZ(proc_path, out_buffer) catch \|err\| {	5726	const target = readlinkZ(proc_path, out_buffer) catch \|err\| {
5514	switch (err) {	5727	switch (err) {
5515	error.UnsupportedReparsePointType => unreachable, // Windows only,
5516	error.NotLink => unreachable,	5728	error.NotLink => unreachable,
		5729	error.BadPathName => unreachable,
		5730	error.InvalidUtf8 => unreachable, // WASI-only
		5731	error.InvalidWtf8 => unreachable, // Windows-only
		5732	error.UnsupportedReparsePointType => unreachable, // Windows-only
		5733	error.NetworkNotFound => unreachable, // Windows-only
5517	else => \|e\| return e,	5734	else => \|e\| return e,
5518	}	5735	}
5519	};	5736	};

lib/std/os/windows.zig+51-37

 @@ -1,8 +1,8 @@
 //! This file contains thin wrappers around Windows-specific APIs, with these
 //! specific goals in mind:
 //! * Convert "errno"-style error codes into Zig errors.
-//! * When null-terminated or UTF16LE byte buffers are required, provide APIs which accept
+//! * When null-terminated or WTF16LE byte buffers are required, provide APIs which accept
-//!   slices as well as APIs which accept null-terminated UTF16LE byte buffers.
+//!   slices as well as APIs which accept null-terminated WTF16LE byte buffers.
 const builtin = @import("builtin");
 const std = @import("../std.zig");
 @@ -548,7 +548,6 @@ pub fn WriteFile(
 pub const SetCurrentDirectoryError = error{
     NameTooLong,
-    InvalidUtf8,
     FileNotFound,
     NotDir,
     AccessDenied,
 @@ -587,24 +586,24 @@ pub const GetCurrentDirectoryError = error{
 };
 /// The result is a slice of `buffer`, indexed from 0.
+/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
 pub fn GetCurrentDirectory(buffer: []u8) GetCurrentDirectoryError![]u8 {
-    var utf16le_buf: [PATH_MAX_WIDE]u16 = undefined;
+    var wtf16le_buf: [PATH_MAX_WIDE]u16 = undefined;
-    const result = kernel32.GetCurrentDirectoryW(utf16le_buf.len, &utf16le_buf);
+    const result = kernel32.GetCurrentDirectoryW(wtf16le_buf.len, &wtf16le_buf);
     if (result == 0) {
         switch (kernel32.GetLastError()) {
             else => |err| return unexpectedError(err),
         }
     }
-    assert(result <= utf16le_buf.len);
+    assert(result <= wtf16le_buf.len);
-    const utf16le_slice = utf16le_buf[0..result];
+    const wtf16le_slice = wtf16le_buf[0..result];
-    // Trust that Windows gives us valid UTF-16LE.
     var end_index: usize = 0;
-    var it = std.unicode.Utf16LeIterator.init(utf16le_slice);
+    var it = std.unicode.Wtf16LeIterator.init(wtf16le_slice);
-    while (it.nextCodepoint() catch unreachable) |codepoint| {
+    while (it.nextCodepoint()) |codepoint| {
         const seq_len = std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
         if (end_index + seq_len >= buffer.len)
             return error.NameTooLong;
-        end_index += std.unicode.utf8Encode(codepoint, buffer[end_index..]) catch unreachable;
+        end_index += std.unicode.wtf8Encode(codepoint, buffer[end_index..]) catch unreachable;
     }
     return buffer[0..end_index];
 }
 @@ -812,6 +811,8 @@ pub fn ReadLink(dir: ?HANDLE, sub_path_w: []const u16, out_buffer: []u8) ReadLin
     }
 }
+/// Asserts that there is enough space is `out_buffer`.
+/// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
 fn parseReadlinkPath(path: []const u16, is_relative: bool, out_buffer: []u8) []u8 {
     const win32_namespace_path = path: {
         if (is_relative) break :path path;
 @@ -821,7 +822,7 @@ fn parseReadlinkPath(path: []const u16, is_relative: bool, out_buffer: []u8) []u
         };
         break :path win32_path.span();
     };
-    const out_len = std.unicode.utf16LeToUtf8(out_buffer, win32_namespace_path) catch unreachable;
+    const out_len = std.unicode.wtf16LeToWtf8(out_buffer, win32_namespace_path);
     return out_buffer[0..out_len];
 }
 @@ -1942,13 +1943,13 @@ pub fn eqlIgnoreCaseWTF16(a: []const u16, b: []const u16) bool {
     if (@inComptime() or builtin.os.tag != .windows) {
         // This function compares the strings code unit by code unit (aka u16-to-u16),
         // so any length difference implies inequality. In other words, there's no possible
-        // conversion that changes the number of UTF-16 code units needed for the uppercase/lowercase
+        // conversion that changes the number of WTF-16 code units needed for the uppercase/lowercase
         // version in the conversion table since only codepoints <= max(u16) are eligible
         // for conversion at all.
         if (a.len != b.len) return false;
         for (a, b) |a_c, b_c| {
-            // The slices are always UTF-16 LE, so need to convert the elements to native
+            // The slices are always WTF-16 LE, so need to convert the elements to native
             // endianness for the uppercasing
             const a_c_native = std.mem.littleToNative(u16, a_c);
             const b_c_native = std.mem.littleToNative(u16, b_c);
 @@ -1975,18 +1976,18 @@ pub fn eqlIgnoreCaseWTF16(a: []const u16, b: []const u16) bool {
     return ntdll.RtlEqualUnicodeString(&a_string, &b_string, TRUE) == TRUE;
 }
-/// Compares two UTF-8 strings using the equivalent functionality of
+/// Compares two WTF-8 strings using the equivalent functionality of
 /// `RtlEqualUnicodeString` (with case insensitive comparison enabled).
 /// This function can be called on any target.
-/// Assumes `a` and `b` are valid UTF-8.
+/// Assumes `a` and `b` are valid WTF-8.
-pub fn eqlIgnoreCaseUtf8(a: []const u8, b: []const u8) bool {
+pub fn eqlIgnoreCaseWtf8(a: []const u8, b: []const u8) bool {
     // A length equality check is not possible here because there are
     // some codepoints that have a different length uppercase UTF-8 representations
     // than their lowercase counterparts, e.g. U+0250 (2 bytes) <-> U+2C6F (3 bytes).
     // There are 7 such codepoints in the uppercase data used by Windows.
-    var a_utf8_it = std.unicode.Utf8View.initUnchecked(a).iterator();
+    var a_wtf8_it = std.unicode.Wtf8View.initUnchecked(a).iterator();
-    var b_utf8_it = std.unicode.Utf8View.initUnchecked(b).iterator();
+    var b_wtf8_it = std.unicode.Wtf8View.initUnchecked(b).iterator();
     // Use RtlUpcaseUnicodeChar on Windows when not in comptime to avoid including a
     // redundant copy of the uppercase data.
 @@ -1996,8 +1997,8 @@ pub fn eqlIgnoreCaseUtf8(a: []const u8, b: []const u8) bool {
     };
     while (true) {
-        const a_cp = a_utf8_it.nextCodepoint() orelse break;
+        const a_cp = a_wtf8_it.nextCodepoint() orelse break;
-        const b_cp = b_utf8_it.nextCodepoint() orelse return false;
+        const b_cp = b_wtf8_it.nextCodepoint() orelse return false;
         if (a_cp <= std.math.maxInt(u16) and b_cp <= std.math.maxInt(u16)) {
             if (a_cp != b_cp and upcaseImpl(@intCast(a_cp)) != upcaseImpl(@intCast(b_cp))) {
 @@ -2008,26 +2009,26 @@ pub fn eqlIgnoreCaseUtf8(a: []const u8, b: []const u8) bool {
         }
     }
     // Make sure there are no leftover codepoints in b
-    if (b_utf8_it.nextCodepoint() != null) return false;
+    if (b_wtf8_it.nextCodepoint() != null) return false;
     return true;
 }
 fn testEqlIgnoreCase(comptime expect_eql: bool, comptime a: []const u8, comptime b: []const u8) !void {
-    try std.testing.expectEqual(expect_eql, eqlIgnoreCaseUtf8(a, b));
+    try std.testing.expectEqual(expect_eql, eqlIgnoreCaseWtf8(a, b));
     try std.testing.expectEqual(expect_eql, eqlIgnoreCaseWTF16(
         std.unicode.utf8ToUtf16LeStringLiteral(a),
         std.unicode.utf8ToUtf16LeStringLiteral(b),
     ));
-    try comptime std.testing.expect(expect_eql == eqlIgnoreCaseUtf8(a, b));
+    try comptime std.testing.expect(expect_eql == eqlIgnoreCaseWtf8(a, b));
     try comptime std.testing.expect(expect_eql == eqlIgnoreCaseWTF16(
         std.unicode.utf8ToUtf16LeStringLiteral(a),
         std.unicode.utf8ToUtf16LeStringLiteral(b),
     ));
 }
-test "eqlIgnoreCaseWTF16/Utf8" {
+test "eqlIgnoreCaseWTF16/Wtf8" {
     try testEqlIgnoreCase(true, "\x01 a B Λ ɐ", "\x01 A b λ Ɐ");
     // does not do case-insensitive comparison for codepoints >= U+10000
     try testEqlIgnoreCase(false, "𐓏", "𐓷");
 @@ -2117,20 +2118,32 @@ pub fn normalizePath(comptime T: type, path: []T) RemoveDotDirsError!usize {
     return prefix_len + try removeDotDirsSanitized(T, path[prefix_len..new_len]);
 }
+pub const Wtf8ToPrefixedFileWError = error{InvalidWtf8} || Wtf16ToPrefixedFileWError;
 /// Same as `sliceToPrefixedFileW` but accepts a pointer
-/// to a null-terminated path.
+/// to a null-terminated WTF-8 encoded path.
-pub fn cStrToPrefixedFileW(dir: ?HANDLE, s: [*:0]const u8) !PathSpace {
+/// https://simonsapin.github.io/wtf-8/
+pub fn cStrToPrefixedFileW(dir: ?HANDLE, s: [*:0]const u8) Wtf8ToPrefixedFileWError!PathSpace {
     return sliceToPrefixedFileW(dir, mem.sliceTo(s, 0));
 }
-/// Same as `wToPrefixedFileW` but accepts a UTF-8 encoded path.
+/// Same as `wToPrefixedFileW` but accepts a WTF-8 encoded path.
-pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) !PathSpace {
+/// https://simonsapin.github.io/wtf-8/
+pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) Wtf8ToPrefixedFileWError!PathSpace {
     var temp_path: PathSpace = undefined;
-    temp_path.len = try std.unicode.utf8ToUtf16Le(&temp_path.data, path);
+    temp_path.len = try std.unicode.wtf8ToWtf16Le(&temp_path.data, path);
     temp_path.data[temp_path.len] = 0;
     return wToPrefixedFileW(dir, temp_path.span());
 }
+pub const Wtf16ToPrefixedFileWError = error{
+    AccessDenied,
+    BadPathName,
+    FileNotFound,
+    NameTooLong,
+    Unexpected,
+};
 /// Converts the `path` to WTF16, null-terminated. If the path contains any
 /// namespace prefix, or is anything but a relative path (rooted, drive relative,
 /// etc) the result will have the NT-style prefix `\??\`.
 @@ -2142,7 +2155,7 @@ pub fn sliceToPrefixedFileW(dir: ?HANDLE, path: []const u8) !PathSpace {
 ///   is non-null, or the CWD if it is null.
 /// - Special case device names like COM1, NUL, etc are not handled specially (TODO)
 /// - . and space are not stripped from the end of relative paths (potential TODO)
-pub fn wToPrefixedFileW(dir: ?HANDLE, path: [:0]const u16) !PathSpace {
+pub fn wToPrefixedFileW(dir: ?HANDLE, path: [:0]const u16) Wtf16ToPrefixedFileWError!PathSpace {
     const nt_prefix = [_]u16{ '\\', '?', '?', '\\' };
     switch (getNamespacePrefix(u16, path)) {
         // TODO: Figure out a way to design an API that can avoid the copy for .nt,
 @@ -2312,7 +2325,7 @@ pub const NamespacePrefix = enum {
     nt,
 };
-/// If `T` is `u16`, then `path` should be encoded as UTF-16LE.
+/// If `T` is `u16`, then `path` should be encoded as WTF-16LE.
 pub fn getNamespacePrefix(comptime T: type, path: []const T) NamespacePrefix {
     if (path.len < 4) return .none;
     var all_backslash = switch (mem.littleToNative(T, path[0])) {
 @@ -2366,7 +2379,7 @@ pub const UnprefixedPathType = enum {
 /// Get the path type of a path that is known to not have any namespace prefixes
 /// (`\\?\`, `\\.\`, `\??\`).
-/// If `T` is `u16`, then `path` should be encoded as UTF-16LE.
+/// If `T` is `u16`, then `path` should be encoded as WTF-16LE.
 pub fn getUnprefixedPathType(comptime T: type, path: []const T) UnprefixedPathType {
     if (path.len < 1) return .relative;
 @@ -2420,7 +2433,7 @@ test getUnprefixedPathType {
 /// Functionality is based on the ReactOS test cases found here:
 /// https://github.com/reactos/reactos/blob/master/modules/rostests/apitests/ntdll/RtlNtPathNameToDosPathName.c
 ///
-/// `path` should be encoded as UTF-16LE.
+/// `path` should be encoded as WTF-16LE.
 pub fn ntToWin32Namespace(path: []const u16) !PathSpace {
     if (path.len > PATH_MAX_WIDE) return error.NameTooLong;
 @@ -2530,7 +2543,6 @@ pub fn unexpectedError(err: Win32Error) std.os.UnexpectedError {
     if (std.os.unexpected_error_tracing) {
         // 614 is the length of the longest windows error description
         var buf_wstr: [614]WCHAR = undefined;
-        var buf_utf8: [614]u8 = undefined;
         const len = kernel32.FormatMessageW(
             FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
             null,
 @@ -2540,8 +2552,10 @@ pub fn unexpectedError(err: Win32Error) std.os.UnexpectedError {
             buf_wstr.len,
             null,
         );
-        _ = std.unicode.utf16LeToUtf8(&buf_utf8, buf_wstr[0..len]) catch unreachable;
+        std.debug.print("error.Unexpected: GetLastError({}): {}\n", .{
-        std.debug.print("error.Unexpected: GetLastError({}): {s}\n", .{ @intFromEnum(err), buf_utf8[0..len] });
+            @intFromEnum(err),
+            std.unicode.fmtUtf16Le(buf_wstr[0..len]),
+        });
         std.debug.dumpCurrentStackTrace(@returnAddress());
     }
     return error.Unexpected;

lib/std/process.zig+89-63

 @@ -16,11 +16,15 @@ pub const changeCurDir = os.chdir;
 pub const changeCurDirC = os.chdirC;
 /// The result is a slice of `out_buffer`, from index `0`.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 pub fn getCwd(out_buffer: []u8) ![]u8 {
     return os.getcwd(out_buffer);
 }
 /// Caller must free the returned memory.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 pub fn getCwdAlloc(allocator: Allocator) ![]u8 {
     // The use of MAX_PATH_BYTES here is just a heuristic: most paths will fit
     // in stack_buf, avoiding an extra allocation in the common case.
 @@ -76,7 +80,7 @@ pub const EnvMap = struct {
             _ = self;
             if (builtin.os.tag == .windows) {
                 var h = std.hash.Wyhash.init(0);
-                var it = std.unicode.Utf8View.initUnchecked(s).iterator();
+                var it = std.unicode.Wtf8View.initUnchecked(s).iterator();
                 while (it.nextCodepoint()) |cp| {
                     const cp_upper = upcase(cp);
                     h.update(&[_]u8{
 @@ -93,8 +97,8 @@ pub const EnvMap = struct {
         pub fn eql(self: @This(), a: []const u8, b: []const u8) bool {
             _ = self;
             if (builtin.os.tag == .windows) {
-                var it_a = std.unicode.Utf8View.initUnchecked(a).iterator();
+                var it_a = std.unicode.Wtf8View.initUnchecked(a).iterator();
-                var it_b = std.unicode.Utf8View.initUnchecked(b).iterator();
+                var it_b = std.unicode.Wtf8View.initUnchecked(b).iterator();
                 while (true) {
                     const c_a = it_a.nextCodepoint() orelse break;
                     const c_b = it_b.nextCodepoint() orelse return false;
 @@ -129,8 +133,9 @@ pub const EnvMap = struct {
     /// Same as `put` but the key and value become owned by the EnvMap rather
     /// than being copied.
     /// If `putMove` fails, the ownership of key and value does not transfer.
-    /// On Windows `key` must be a valid UTF-8 string.
+    /// On Windows `key` must be a valid [WTF-8](https://simonsapin.github.io/wtf-8/) string.
     pub fn putMove(self: *EnvMap, key: []u8, value: []u8) !void {
+        assert(std.unicode.wtf8ValidateSlice(key));
         const get_or_put = try self.hash_map.getOrPut(key);
         if (get_or_put.found_existing) {
             self.free(get_or_put.key_ptr.*);
 @@ -141,8 +146,9 @@ pub const EnvMap = struct {
     }
     /// `key` and `value` are copied into the EnvMap.
-    /// On Windows `key` must be a valid UTF-8 string.
+    /// On Windows `key` must be a valid [WTF-8](https://simonsapin.github.io/wtf-8/) string.
     pub fn put(self: *EnvMap, key: []const u8, value: []const u8) !void {
+        assert(std.unicode.wtf8ValidateSlice(key));
         const value_copy = try self.copy(value);
         errdefer self.free(value_copy);
         const get_or_put = try self.hash_map.getOrPut(key);
 @@ -159,23 +165,26 @@ pub const EnvMap = struct {
     /// Find the address of the value associated with a key.
     /// The returned pointer is invalidated if the map resizes.
-    /// On Windows `key` must be a valid UTF-8 string.
+    /// On Windows `key` must be a valid [WTF-8](https://simonsapin.github.io/wtf-8/) string.
     pub fn getPtr(self: EnvMap, key: []const u8) ?*[]const u8 {
+        assert(std.unicode.wtf8ValidateSlice(key));
         return self.hash_map.getPtr(key);
     }
     /// Return the map's copy of the value associated with
     /// a key.  The returned string is invalidated if this
     /// key is removed from the map.
-    /// On Windows `key` must be a valid UTF-8 string.
+    /// On Windows `key` must be a valid [WTF-8](https://simonsapin.github.io/wtf-8/) string.
     pub fn get(self: EnvMap, key: []const u8) ?[]const u8 {
+        assert(std.unicode.wtf8ValidateSlice(key));
         return self.hash_map.get(key);
     }
     /// Removes the item from the map and frees its value.
     /// This invalidates the value returned by get() for this key.
-    /// On Windows `key` must be a valid UTF-8 string.
+    /// On Windows `key` must be a valid [WTF-8](https://simonsapin.github.io/wtf-8/) string.
     pub fn remove(self: *EnvMap, key: []const u8) void {
+        assert(std.unicode.wtf8ValidateSlice(key));
         const kv = self.hash_map.fetchRemove(key) orelse return;
         self.free(kv.key);
         self.free(kv.value);
 @@ -239,18 +248,34 @@ test "EnvMap" {
     try testing.expectEqual(@as(EnvMap.Size, 1), env.count());
-    // test Unicode case-insensitivity on Windows
     if (builtin.os.tag == .windows) {
+        // test Unicode case-insensitivity on Windows
         try env.put("КИРиллИЦА", "something else");
         try testing.expectEqualStrings("something else", env.get("кириллица").?);
+        // and WTF-8 that's not valid UTF-8
+        const wtf8_with_surrogate_pair = try std.unicode.wtf16LeToWtf8Alloc(testing.allocator, &[_]u16{
+            std.mem.nativeToLittle(u16, 0xD83D), // unpaired high surrogate
+        });
+        defer testing.allocator.free(wtf8_with_surrogate_pair);
+        try env.put(wtf8_with_surrogate_pair, wtf8_with_surrogate_pair);
+        try testing.expectEqualSlices(u8, wtf8_with_surrogate_pair, env.get(wtf8_with_surrogate_pair).?);
     }
 }
+pub const GetEnvMapError = error{
+    OutOfMemory,
+    /// WASI-only. `environ_sizes_get` or `environ_get`
+    /// failed for an unexpected reason.
+    Unexpected,
+};
 /// Returns a snapshot of the environment variables of the current process.
 /// Any modifications to the resulting EnvMap will not be reflected in the environment, and
 /// likewise, any future modifications to the environment will not be reflected in the EnvMap.
 /// Caller owns resulting `EnvMap` and should call its `deinit` fn when done.
-pub fn getEnvMap(allocator: Allocator) !EnvMap {
+pub fn getEnvMap(allocator: Allocator) GetEnvMapError!EnvMap {
     var result = EnvMap.init(allocator);
     errdefer result.deinit();
 @@ -269,7 +294,7 @@ pub fn getEnvMap(allocator: Allocator) !EnvMap {
             while (ptr[i] != 0 and ptr[i] != '=') : (i += 1) {}
             const key_w = ptr[key_start..i];
-            const key = try std.unicode.utf16LeToUtf8Alloc(allocator, key_w);
+            const key = try std.unicode.wtf16LeToWtf8Alloc(allocator, key_w);
             errdefer allocator.free(key);
             if (ptr[i] == '=') i += 1;
 @@ -277,7 +302,7 @@ pub fn getEnvMap(allocator: Allocator) !EnvMap {
             const value_start = i;
             while (ptr[i] != 0) : (i += 1) {}
             const value_w = ptr[value_start..i];
-            const value = try std.unicode.utf16LeToUtf8Alloc(allocator, value_w);
+            const value = try std.unicode.wtf16LeToWtf8Alloc(allocator, value_w);
             errdefer allocator.free(value);
             i += 1; // skip over null byte
 @@ -355,25 +380,26 @@ pub const GetEnvVarOwnedError = error{
     OutOfMemory,
     EnvironmentVariableNotFound,
-    /// See https://github.com/ziglang/zig/issues/1774
+    /// On Windows, environment variable keys provided by the user must be valid WTF-8.
-    InvalidUtf8,
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
 };
 /// Caller must free returned memory.
+/// On Windows, if `key` is not valid [WTF-8](https://simonsapin.github.io/wtf-8/),
+/// then `error.InvalidWtf8` is returned.
+/// On Windows, the value is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the value is an opaque sequence of bytes with no particular encoding.
 pub fn getEnvVarOwned(allocator: Allocator, key: []const u8) GetEnvVarOwnedError![]u8 {
     if (builtin.os.tag == .windows) {
         const result_w = blk: {
-            const key_w = try std.unicode.utf8ToUtf16LeAllocZ(allocator, key);
+            const key_w = try std.unicode.wtf8ToWtf16LeAllocZ(allocator, key);
             defer allocator.free(key_w);
             break :blk std.os.getenvW(key_w) orelse return error.EnvironmentVariableNotFound;
         };
-        return std.unicode.utf16LeToUtf8Alloc(allocator, result_w) catch |err| switch (err) {
+        // wtf16LeToWtf8Alloc can only fail with OutOfMemory
-            error.DanglingSurrogateHalf => return error.InvalidUtf8,
+        return std.unicode.wtf16LeToWtf8Alloc(allocator, result_w);
-            error.ExpectedSecondSurrogateHalf => return error.InvalidUtf8,
-            error.UnexpectedSecondSurrogateHalf => return error.InvalidUtf8,
-            else => |e| return e,
-        };
     } else if (builtin.os.tag == .wasi and !builtin.link_libc) {
         var envmap = getEnvMap(allocator) catch return error.OutOfMemory;
         defer envmap.deinit();
 @@ -385,6 +411,7 @@ pub fn getEnvVarOwned(allocator: Allocator, key: []const u8) GetEnvVarOwnedError
     }
 }
+/// On Windows, `key` must be valid UTF-8.
 pub fn hasEnvVarConstant(comptime key: []const u8) bool {
     if (builtin.os.tag == .windows) {
         const key_w = comptime std.unicode.utf8ToUtf16LeStringLiteral(key);
 @@ -396,11 +423,22 @@ pub fn hasEnvVarConstant(comptime key: []const u8) bool {
     }
 }
-pub fn hasEnvVar(allocator: Allocator, key: []const u8) error{OutOfMemory}!bool {
+pub const HasEnvVarError = error{
+    OutOfMemory,
+    /// On Windows, environment variable keys provided by the user must be valid WTF-8.
+    /// https://simonsapin.github.io/wtf-8/
+    InvalidWtf8,
+};
+/// On Windows, if `key` is not valid [WTF-8](https://simonsapin.github.io/wtf-8/),
+/// then `error.InvalidWtf8` is returned.
+pub fn hasEnvVar(allocator: Allocator, key: []const u8) HasEnvVarError!bool {
     if (builtin.os.tag == .windows) {
         var stack_alloc = std.heap.stackFallback(256 * @sizeOf(u16), allocator);
-        const key_w = try std.unicode.utf8ToUtf16LeAllocZ(stack_alloc.get(), key);
+        const stack_allocator = stack_alloc.get();
-        defer stack_alloc.allocator.free(key_w);
+        const key_w = try std.unicode.wtf8ToWtf16LeAllocZ(stack_allocator, key);
+        defer stack_allocator.free(key_w);
         return std.os.getenvW(key_w) != null;
     } else if (builtin.os.tag == .wasi and !builtin.link_libc) {
         var envmap = getEnvMap(allocator) catch return error.OutOfMemory;
 @@ -411,9 +449,22 @@ pub fn hasEnvVar(allocator: Allocator, key: []const u8) error{OutOfMemory}!bool
     }
 }
-test "os.getEnvVarOwned" {
+test getEnvVarOwned {
-    const ga = std.testing.allocator;
+    try testing.expectError(
-    try testing.expectError(error.EnvironmentVariableNotFound, getEnvVarOwned(ga, "BADENV"));
+        error.EnvironmentVariableNotFound,
+        getEnvVarOwned(std.testing.allocator, "BADENV"),
+    );
+}
+test hasEnvVarConstant {
+    if (builtin.os.tag == .wasi and !builtin.link_libc) return error.SkipZigTest;
+    try testing.expect(!hasEnvVarConstant("BADENV"));
+}
+test hasEnvVar {
+    const has_env = try hasEnvVar(std.testing.allocator, "BADENV");
+    try testing.expect(!has_env);
 }
 pub const ArgIteratorPosix = struct {
 @@ -531,6 +582,7 @@ pub const ArgIteratorWasi = struct {
 pub const ArgIteratorWindows = struct {
     allocator: Allocator,
     /// Owned by the iterator.
+    /// Encoded as WTF-8.
     cmd_line: []const u8,
     index: usize = 0,
     /// Owned by the iterator. Long enough to hold the entire `cmd_line` plus a null terminator.
 @@ -538,20 +590,14 @@ pub const ArgIteratorWindows = struct {
     start: usize = 0,
     end: usize = 0,
-    pub const InitError = error{ OutOfMemory, InvalidCmdLine };
+    pub const InitError = error{OutOfMemory};
-    /// `cmd_line_w` *must* be an UTF16-LE-encoded string.
+    /// `cmd_line_w` *must* be a WTF16-LE-encoded string.
     ///
-    /// The iterator makes a copy of `cmd_line_w` converted UTF-8 and keeps it; it does *not* take
+    /// The iterator makes a copy of `cmd_line_w` converted WTF-8 and keeps it; it does *not* take
     /// ownership of `cmd_line_w`.
     pub fn init(allocator: Allocator, cmd_line_w: [*:0]const u16) InitError!ArgIteratorWindows {
-        const cmd_line = std.unicode.utf16LeToUtf8Alloc(allocator, mem.sliceTo(cmd_line_w, 0)) catch |err| switch (err) {
+        const cmd_line = try std.unicode.wtf16LeToWtf8Alloc(allocator, mem.sliceTo(cmd_line_w, 0));
-            error.DanglingSurrogateHalf,
-            error.ExpectedSecondSurrogateHalf,
-            error.UnexpectedSecondSurrogateHalf,
-            => return error.InvalidCmdLine,
-            error.OutOfMemory => return error.OutOfMemory,
-        };
         errdefer allocator.free(cmd_line);
         const buffer = try allocator.alloc(u8, cmd_line.len + 1);
 @@ -566,6 +612,7 @@ pub const ArgIteratorWindows = struct {
     /// Returns the next argument and advances the iterator. Returns `null` if at the end of the
     /// command-line string. The iterator owns the returned slice.
+    /// The result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
     pub fn next(self: *ArgIteratorWindows) ?[:0]const u8 {
         return self.nextWithStrategy(next_strategy);
     }
 @@ -777,7 +824,6 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type {
         pub const Self = @This();
         pub const InitError = error{OutOfMemory};
-        pub const InitUtf16leError = error{ OutOfMemory, InvalidCmdLine };
         /// cmd_line_utf8 MUST remain valid and constant while using this instance
         pub fn init(allocator: Allocator, cmd_line_utf8: []const u8) InitError!Self {
 @@ -805,30 +851,6 @@ pub fn ArgIteratorGeneral(comptime options: ArgIteratorGeneralOptions) type {
             };
         }
-        /// cmd_line_utf16le MUST be encoded UTF16-LE, and is converted to UTF-8 in an internal buffer
-        pub fn initUtf16le(allocator: Allocator, cmd_line_utf16le: [*:0]const u16) InitUtf16leError!Self {
-            const utf16le_slice = mem.sliceTo(cmd_line_utf16le, 0);
-            const cmd_line = std.unicode.utf16LeToUtf8Alloc(allocator, utf16le_slice) catch |err| switch (err) {
-                error.ExpectedSecondSurrogateHalf,
-                error.DanglingSurrogateHalf,
-                error.UnexpectedSecondSurrogateHalf,
-                => return error.InvalidCmdLine,
-                error.OutOfMemory => return error.OutOfMemory,
-            };
-            errdefer allocator.free(cmd_line);
-            const buffer = try allocator.alloc(u8, cmd_line.len + 1);
-            errdefer allocator.free(buffer);
-            return Self{
-                .allocator = allocator,
-                .cmd_line = cmd_line,
-                .free_cmd_line_on_deinit = true,
-                .buffer = buffer,
-            };
-        }
         // Skips over whitespace in the cmd_line.
         // Returns false if the terminating sentinel is reached, true otherwise.
         // Also skips over comments (if supported).
 @@ -1021,6 +1043,8 @@ pub const ArgIterator = struct {
     /// Get the next argument. Returns 'null' if we are at the end.
     /// Returned slice is pointing to the iterator's internal buffer.
+    /// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+    /// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
     pub fn next(self: *ArgIterator) ?([:0]const u8) {
         return self.inner.next();
     }
 @@ -1057,6 +1081,8 @@ pub fn argsWithAllocator(allocator: Allocator) ArgIterator.InitError!ArgIterator
 }
 /// Caller must call argsFree on result.
+/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
+/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
 pub fn argsAlloc(allocator: Allocator) ![][:0]u8 {
     // TODO refactor to only make 1 allocation.
     var it = try argsWithAllocator(allocator);
 @@ -1201,7 +1227,7 @@ test "ArgIteratorWindows" {
 }
 fn testArgIteratorWindows(cmd_line: []const u8, expected_args: []const []const u8) !void {
-    const cmd_line_w = try std.unicode.utf8ToUtf16LeAllocZ(testing.allocator, cmd_line);
+    const cmd_line_w = try std.unicode.wtf8ToWtf16LeAllocZ(testing.allocator, cmd_line);
     defer testing.allocator.free(cmd_line_w);
     // next

lib/std/unicode.zig+50-28

 @@ -488,7 +488,9 @@ pub const Utf16LeIterator = struct {
         };
     }
-    pub fn nextCodepoint(it: *Utf16LeIterator) !?u21 {
+    pub const NextCodepointError = error{ DanglingSurrogateHalf, ExpectedSecondSurrogateHalf, UnexpectedSecondSurrogateHalf };
+    pub fn nextCodepoint(it: *Utf16LeIterator) NextCodepointError!?u21 {
         assert(it.i <= it.bytes.len);
         if (it.i == it.bytes.len) return null;
         var code_units: [2]u16 = undefined;
 @@ -923,7 +925,14 @@ test "fmtUtf8" {
     try expectFmt("����A", "{}", .{fmtUtf8("\xE1\x80\xE2\xF0\x91\x92\xF1\xBFA")});
 }
-fn utf16LeToUtf8ArrayListImpl(array_list: *std.ArrayList(u8), utf16le: []const u16, comptime surrogates: Surrogates) !void {
+fn utf16LeToUtf8ArrayListImpl(
+    array_list: *std.ArrayList(u8),
+    utf16le: []const u16,
+    comptime surrogates: Surrogates,
+) (switch (surrogates) {
+    .cannot_encode_surrogate_half => Utf16LeToUtf8AllocError,
+    .can_encode_surrogate_half => mem.Allocator.Error,
+})!void {
     // optimistically guess that it will all be ascii.
     try array_list.ensureTotalCapacityPrecise(utf16le.len);
 @@ -975,7 +984,9 @@ fn utf16LeToUtf8ArrayListImpl(array_list: *std.ArrayList(u8), utf16le: []const u
     }
 }
-pub fn utf16LeToUtf8ArrayList(array_list: *std.ArrayList(u8), utf16le: []const u16) !void {
+pub const Utf16LeToUtf8AllocError = mem.Allocator.Error || Utf16LeToUtf8Error;
+pub fn utf16LeToUtf8ArrayList(array_list: *std.ArrayList(u8), utf16le: []const u16) Utf16LeToUtf8AllocError!void {
     return utf16LeToUtf8ArrayListImpl(array_list, utf16le, .cannot_encode_surrogate_half);
 }
 @@ -983,7 +994,7 @@ pub fn utf16LeToUtf8ArrayList(array_list: *std.ArrayList(u8), utf16le: []const u
 pub const utf16leToUtf8Alloc = utf16LeToUtf8Alloc;
 /// Caller must free returned memory.
-pub fn utf16LeToUtf8Alloc(allocator: mem.Allocator, utf16le: []const u16) ![]u8 {
+pub fn utf16LeToUtf8Alloc(allocator: mem.Allocator, utf16le: []const u16) Utf16LeToUtf8AllocError![]u8 {
     // optimistically guess that it will all be ascii.
     var result = try std.ArrayList(u8).initCapacity(allocator, utf16le.len);
     errdefer result.deinit();
 @@ -997,7 +1008,7 @@ pub fn utf16LeToUtf8Alloc(allocator: mem.Allocator, utf16le: []const u16) ![]u8
 pub const utf16leToUtf8AllocZ = utf16LeToUtf8AllocZ;
 /// Caller must free returned memory.
-pub fn utf16LeToUtf8AllocZ(allocator: mem.Allocator, utf16le: []const u16) ![:0]u8 {
+pub fn utf16LeToUtf8AllocZ(allocator: mem.Allocator, utf16le: []const u16) Utf16LeToUtf8AllocError![:0]u8 {
     // optimistically guess that it will all be ascii (and allocate space for the null terminator)
     var result = try std.ArrayList(u8).initCapacity(allocator, utf16le.len + 1);
     errdefer result.deinit();
 @@ -1007,9 +1018,14 @@ pub fn utf16LeToUtf8AllocZ(allocator: mem.Allocator, utf16le: []const u16) ![:0]
     return result.toOwnedSliceSentinel(0);
 }
+pub const Utf16LeToUtf8Error = Utf16LeIterator.NextCodepointError;
 /// Asserts that the output buffer is big enough.
 /// Returns end byte index into utf8.
-fn utf16LeToUtf8Impl(utf8: []u8, utf16le: []const u16, comptime surrogates: Surrogates) !usize {
+fn utf16LeToUtf8Impl(utf8: []u8, utf16le: []const u16, comptime surrogates: Surrogates) (switch (surrogates) {
+    .cannot_encode_surrogate_half => Utf16LeToUtf8Error,
+    .can_encode_surrogate_half => error{},
+})!usize {
     var end_index: usize = 0;
     var remaining = utf16le;
 @@ -1043,7 +1059,9 @@ fn utf16LeToUtf8Impl(utf8: []u8, utf16le: []const u16, comptime surrogates: Surr
                     // The maximum possible codepoint encoded by UTF-16 is U+10FFFF,
                     // which is within the valid codepoint range.
                     error.CodepointTooLarge => unreachable,
-                    else => |e| return e,
+                    // We know the codepoint was valid in UTF-16, meaning it is not
+                    // an unpaired surrogate codepoint.
+                    error.Utf8CannotEncodeSurrogateHalf => unreachable,
                 };
             }
         },
 @@ -1064,7 +1082,7 @@ fn utf16LeToUtf8Impl(utf8: []u8, utf16le: []const u16, comptime surrogates: Surr
 /// Deprecated; renamed to utf16LeToUtf8
 pub const utf16leToUtf8 = utf16LeToUtf8;
-pub fn utf16LeToUtf8(utf8: []u8, utf16le: []const u16) !usize {
+pub fn utf16LeToUtf8(utf8: []u8, utf16le: []const u16) Utf16LeToUtf8Error!usize {
     return utf16LeToUtf8Impl(utf8, utf16le, .cannot_encode_surrogate_half);
 }
 @@ -1176,11 +1194,11 @@ fn utf8ToUtf16LeArrayListImpl(array_list: *std.ArrayList(u16), utf8: []const u8,
     }
 }
-pub fn utf8ToUtf16LeArrayList(array_list: *std.ArrayList(u16), utf8: []const u8) !void {
+pub fn utf8ToUtf16LeArrayList(array_list: *std.ArrayList(u16), utf8: []const u8) error{ InvalidUtf8, OutOfMemory }!void {
     return utf8ToUtf16LeArrayListImpl(array_list, utf8, .cannot_encode_surrogate_half);
 }
-pub fn utf8ToUtf16LeAlloc(allocator: mem.Allocator, utf8: []const u8) ![]u16 {
+pub fn utf8ToUtf16LeAlloc(allocator: mem.Allocator, utf8: []const u8) error{ InvalidUtf8, OutOfMemory }![]u16 {
     // optimistically guess that it will not require surrogate pairs
     var result = try std.ArrayList(u16).initCapacity(allocator, utf8.len);
     errdefer result.deinit();
 @@ -1193,7 +1211,7 @@ pub fn utf8ToUtf16LeAlloc(allocator: mem.Allocator, utf8: []const u8) ![]u16 {
 /// Deprecated; renamed to utf8ToUtf16LeAllocZ
 pub const utf8ToUtf16LeWithNull = utf8ToUtf16LeAllocZ;
-pub fn utf8ToUtf16LeAllocZ(allocator: mem.Allocator, utf8: []const u8) ![:0]u16 {
+pub fn utf8ToUtf16LeAllocZ(allocator: mem.Allocator, utf8: []const u8) error{ InvalidUtf8, OutOfMemory }![:0]u16 {
     // optimistically guess that it will not require surrogate pairs
     var result = try std.ArrayList(u16).initCapacity(allocator, utf8.len + 1);
     errdefer result.deinit();
 @@ -1205,7 +1223,7 @@ pub fn utf8ToUtf16LeAllocZ(allocator: mem.Allocator, utf8: []const u8) ![:0]u16
 /// Returns index of next character. If exact fit, returned index equals output slice length.
 /// Assumes there is enough space for the output.
-pub fn utf8ToUtf16Le(utf16le: []u16, utf8: []const u8) !usize {
+pub fn utf8ToUtf16Le(utf16le: []u16, utf8: []const u8) error{InvalidUtf8}!usize {
     return utf8ToUtf16LeImpl(utf16le, utf8, .cannot_encode_surrogate_half);
 }
 @@ -1236,11 +1254,14 @@ pub fn utf8ToUtf16LeImpl(utf16le: []u16, utf8: []const u8, comptime surrogates:
     var src_i: usize = 0;
     while (src_i < remaining.len) {
-        const n = utf8ByteSequenceLength(remaining[src_i]) catch return error.InvalidUtf8;
+        const n = utf8ByteSequenceLength(remaining[src_i]) catch return switch (surrogates) {
+            .cannot_encode_surrogate_half => error.InvalidUtf8,
+            .can_encode_surrogate_half => error.InvalidWtf8,
+        };
         const next_src_i = src_i + n;
         const codepoint = switch (surrogates) {
             .cannot_encode_surrogate_half => utf8Decode(remaining[src_i..next_src_i]) catch return error.InvalidUtf8,
-            .can_encode_surrogate_half => wtf8Decode(remaining[src_i..next_src_i]) catch return error.InvalidUtf8,
+            .can_encode_surrogate_half => wtf8Decode(remaining[src_i..next_src_i]) catch return error.InvalidWtf8,
         };
         if (codepoint < 0x10000) {
             const short = @as(u16, @intCast(codepoint));
 @@ -1600,9 +1621,9 @@ fn testValidateWtf8Slice() !void {
 pub const Wtf8View = struct {
     bytes: []const u8,
-    pub fn init(s: []const u8) !Wtf8View {
+    pub fn init(s: []const u8) error{InvalidWtf8}!Wtf8View {
         if (!wtf8ValidateSlice(s)) {
-            return error.InvalidUtf8;
+            return error.InvalidWtf8;
         }
         return initUnchecked(s);
 @@ -1614,8 +1635,8 @@ pub const Wtf8View = struct {
     pub inline fn initComptime(comptime s: []const u8) Wtf8View {
         return comptime if (init(s)) |r| r else |err| switch (err) {
-            error.InvalidUtf8 => {
+            error.InvalidWtf8 => {
-                @compileError("invalid utf8 detected in wtf8 string");
+                @compileError("invalid wtf8");
             },
         };
     }
 @@ -1665,12 +1686,12 @@ pub const Wtf8Iterator = struct {
     }
 };
-pub fn wtf16LeToWtf8ArrayList(array_list: *std.ArrayList(u8), utf16le: []const u16) !void {
+pub fn wtf16LeToWtf8ArrayList(array_list: *std.ArrayList(u8), utf16le: []const u16) mem.Allocator.Error!void {
     return utf16LeToUtf8ArrayListImpl(array_list, utf16le, .can_encode_surrogate_half);
 }
 /// Caller must free returned memory.
-pub fn wtf16LeToWtf8Alloc(allocator: mem.Allocator, wtf16le: []const u16) ![]u8 {
+pub fn wtf16LeToWtf8Alloc(allocator: mem.Allocator, wtf16le: []const u16) mem.Allocator.Error![]u8 {
     // optimistically guess that it will all be ascii.
     var result = try std.ArrayList(u8).initCapacity(allocator, wtf16le.len);
     errdefer result.deinit();
 @@ -1681,7 +1702,7 @@ pub fn wtf16LeToWtf8Alloc(allocator: mem.Allocator, wtf16le: []const u16) ![]u8
 }
 /// Caller must free returned memory.
-pub fn wtf16LeToWtf8AllocZ(allocator: mem.Allocator, wtf16le: []const u16) ![:0]u8 {
+pub fn wtf16LeToWtf8AllocZ(allocator: mem.Allocator, wtf16le: []const u16) mem.Allocator.Error![:0]u8 {
     // optimistically guess that it will all be ascii (and allocate space for the null terminator)
     var result = try std.ArrayList(u8).initCapacity(allocator, wtf16le.len + 1);
     errdefer result.deinit();
 @@ -1695,11 +1716,11 @@ pub fn wtf16LeToWtf8(wtf8: []u8, wtf16le: []const u16) usize {
     return utf16LeToUtf8Impl(wtf8, wtf16le, .can_encode_surrogate_half) catch |err| switch (err) {};
 }
-pub fn wtf8ToWtf16LeArrayList(array_list: *std.ArrayList(u16), wtf8: []const u8) !void {
+pub fn wtf8ToWtf16LeArrayList(array_list: *std.ArrayList(u16), wtf8: []const u8) error{ InvalidWtf8, OutOfMemory }!void {
     return utf8ToUtf16LeArrayListImpl(array_list, wtf8, .can_encode_surrogate_half);
 }
-pub fn wtf8ToWtf16LeAlloc(allocator: mem.Allocator, wtf8: []const u8) ![]u16 {
+pub fn wtf8ToWtf16LeAlloc(allocator: mem.Allocator, wtf8: []const u8) error{ InvalidWtf8, OutOfMemory }![]u16 {
     // optimistically guess that it will not require surrogate pairs
     var result = try std.ArrayList(u16).initCapacity(allocator, wtf8.len);
     errdefer result.deinit();
 @@ -1709,7 +1730,7 @@ pub fn wtf8ToWtf16LeAlloc(allocator: mem.Allocator, wtf8: []const u8) ![]u16 {
     return result.toOwnedSlice();
 }
-pub fn wtf8ToWtf16LeAllocZ(allocator: mem.Allocator, wtf8: []const u8) ![:0]u16 {
+pub fn wtf8ToWtf16LeAllocZ(allocator: mem.Allocator, wtf8: []const u8) error{ InvalidWtf8, OutOfMemory }![:0]u16 {
     // optimistically guess that it will not require surrogate pairs
     var result = try std.ArrayList(u16).initCapacity(allocator, wtf8.len + 1);
     errdefer result.deinit();
 @@ -1721,7 +1742,7 @@ pub fn wtf8ToWtf16LeAllocZ(allocator: mem.Allocator, wtf8: []const u8) ![:0]u16
 /// Returns index of next character. If exact fit, returned index equals output slice length.
 /// Assumes there is enough space for the output.
-pub fn wtf8ToWtf16Le(wtf16le: []u16, wtf8: []const u8) !usize {
+pub fn wtf8ToWtf16Le(wtf16le: []u16, wtf8: []const u8) error{InvalidWtf8}!usize {
     return utf8ToUtf16LeImpl(wtf16le, wtf8, .can_encode_surrogate_half);
 }
 @@ -1732,7 +1753,8 @@ pub fn wtf8ToWtf16Le(wtf16le: []u16, wtf8: []const u8) !usize {
 /// In-place conversion is supported when `utf8` and `wtf8` refer to the same slice.
 /// Note: If `wtf8` is entirely composed of well-formed UTF-8, then no conversion is necessary.
 ///       `utf8ValidateSlice` can be used to check if lossy conversion is worthwhile.
-pub fn wtf8ToUtf8Lossy(utf8: []u8, wtf8: []const u8) !void {
+/// If `wtf8` is not valid WTF-8, then `error.InvalidWtf8` is returned.
+pub fn wtf8ToUtf8Lossy(utf8: []u8, wtf8: []const u8) error{InvalidWtf8}!void {
     assert(utf8.len >= wtf8.len);
     const in_place = utf8.ptr == wtf8.ptr;
 @@ -1762,7 +1784,7 @@ pub fn wtf8ToUtf8Lossy(utf8: []u8, wtf8: []const u8) !void {
     }
 }
-pub fn wtf8ToUtf8LossyAlloc(allocator: mem.Allocator, wtf8: []const u8) ![]u8 {
+pub fn wtf8ToUtf8LossyAlloc(allocator: mem.Allocator, wtf8: []const u8) error{ InvalidWtf8, OutOfMemory }![]u8 {
     const utf8 = try allocator.alloc(u8, wtf8.len);
     errdefer allocator.free(utf8);
 @@ -1771,7 +1793,7 @@ pub fn wtf8ToUtf8LossyAlloc(allocator: mem.Allocator, wtf8: []const u8) ![]u8 {
     return utf8;
 }
-pub fn wtf8ToUtf8LossyAllocZ(allocator: mem.Allocator, wtf8: []const u8) ![:0]u8 {
+pub fn wtf8ToUtf8LossyAllocZ(allocator: mem.Allocator, wtf8: []const u8) error{ InvalidWtf8, OutOfMemory }![:0]u8 {
     const utf8 = try allocator.allocSentinel(u8, wtf8.len, 0);
     errdefer allocator.free(utf8);

lib/std/zig/system.zig+8-4

lib/std/zig/system/NativePaths.zig+2-2

...	@@ -41,7 +41,7 @@ pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {	...	@@ -41,7 +41,7 @@ pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {
41	}	41	}
42	}	42	}
43	} else \|err\| switch (err) {	43	} else \|err\| switch (err) {
44	error.InvalidUtf8 => {},	44	error.InvalidWtf8 => unreachable,
45	error.EnvironmentVariableNotFound => {},	45	error.EnvironmentVariableNotFound => {},
46	error.OutOfMemory => \|e\| return e,	46	error.OutOfMemory => \|e\| return e,
47	}	47	}
...	@@ -73,7 +73,7 @@ pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {	...	@@ -73,7 +73,7 @@ pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths {
73	}	73	}
74	}	74	}
75	} else \|err\| switch (err) {	75	} else \|err\| switch (err) {
76	error.InvalidUtf8 => {},	76	error.InvalidWtf8 => unreachable,
77	error.EnvironmentVariableNotFound => {},	77	error.EnvironmentVariableNotFound => {},
78	error.OutOfMemory => \|e\| return e,	78	error.OutOfMemory => \|e\| return e,
79	}	79	}

src/Module.zig+1

...	@@ -2662,6 +2662,7 @@ pub fn astGenFile(mod: Module, file: File) !void {	...	@@ -2662,6 +2662,7 @@ pub fn astGenFile(mod: Module, file: File) !void {
2662	}) catch \|err\| switch (err) {	2662	}) catch \|err\| switch (err) {
2663	error.NotDir => unreachable, // no dir components	2663	error.NotDir => unreachable, // no dir components
2664	error.InvalidUtf8 => unreachable, // it's a hex encoded name	2664	error.InvalidUtf8 => unreachable, // it's a hex encoded name
		2665	error.InvalidWtf8 => unreachable, // it's a hex encoded name
2665	error.BadPathName => unreachable, // it's a hex encoded name	2666	error.BadPathName => unreachable, // it's a hex encoded name
2666	error.NameTooLong => unreachable, // it's a fixed size name	2667	error.NameTooLong => unreachable, // it's a fixed size name
2667	error.PipeBusy => unreachable, // it's not a pipe	2668	error.PipeBusy => unreachable, // it's not a pipe

src/libc_installation.zig+8-2

 @@ -246,7 +246,10 @@ pub const LibCInstallation = struct {
         const allocator = args.allocator;
         // Detect infinite loops.
-        var env_map = try std.process.getEnvMap(allocator);
+        var env_map = std.process.getEnvMap(allocator) catch |err| switch (err) {
+            error.Unexpected => unreachable, // WASI-only
+            else => |e| return e,
+        };
         defer env_map.deinit();
         const skip_cc_env_var = if (env_map.get(inf_loop_env_key)) |phase| blk: {
             if (std.mem.eql(u8, phase, "1")) {
 @@ -572,7 +575,10 @@ fn ccPrintFileName(args: CCPrintFileNameOptions) ![:0]u8 {
     const allocator = args.allocator;
     // Detect infinite loops.
-    var env_map = try std.process.getEnvMap(allocator);
+    var env_map = std.process.getEnvMap(allocator) catch |err| switch (err) {
+        error.Unexpected => unreachable, // WASI-only
+        else => |e| return e,
+    };
     defer env_map.deinit();
     const skip_cc_env_var = if (env_map.get(inf_loop_env_key)) |phase| blk: {
         if (std.mem.eql(u8, phase, "1")) {

src/windows_sdk.zig+87-90

 @@ -84,26 +84,26 @@ fn iterateAndFilterBySemVer(
     return dirs_filtered_slice;
 }
-const RegistryUtf8 = struct {
+const RegistryWtf8 = struct {
     key: windows.HKEY,
-    /// Assert that `key` is valid UTF-8 string
+    /// Assert that `key` is valid WTF-8 string
-    pub fn openKey(hkey: windows.HKEY, key: []const u8) error{KeyNotFound}!RegistryUtf8 {
+    pub fn openKey(hkey: windows.HKEY, key: []const u8) error{KeyNotFound}!RegistryWtf8 {
-        const key_utf16le: [:0]const u16 = key_utf16le: {
+        const key_wtf16le: [:0]const u16 = key_wtf16le: {
-            var key_utf16le_buf: [RegistryUtf16Le.key_name_max_len]u16 = undefined;
+            var key_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const key_utf16le_len: usize = std.unicode.utf8ToUtf16Le(key_utf16le_buf[0..], key) catch |err| switch (err) {
+            const key_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(key_wtf16le_buf[0..], key) catch |err| switch (err) {
-                error.InvalidUtf8 => unreachable,
+                error.InvalidWtf8 => unreachable,
             };
-            key_utf16le_buf[key_utf16le_len] = 0;
+            key_wtf16le_buf[key_wtf16le_len] = 0;
-            break :key_utf16le key_utf16le_buf[0..key_utf16le_len :0];
+            break :key_wtf16le key_wtf16le_buf[0..key_wtf16le_len :0];
         };
-        const registry_utf16le = try RegistryUtf16Le.openKey(hkey, key_utf16le);
+        const registry_wtf16le = try RegistryWtf16Le.openKey(hkey, key_wtf16le);
-        return RegistryUtf8{ .key = registry_utf16le.key };
+        return RegistryWtf8{ .key = registry_wtf16le.key };
     }
     /// Closes key, after that usage is invalid
-    pub fn closeKey(self: *const RegistryUtf8) void {
+    pub fn closeKey(self: *const RegistryWtf8) void {
         const return_code_int: windows.HRESULT = windows.advapi32.RegCloseKey(self.key);
         const return_code: windows.Win32Error = @enumFromInt(return_code_int);
         switch (return_code) {
 @@ -114,71 +114,68 @@ const RegistryUtf8 = struct {
     /// Get string from registry.
     /// Caller owns result.
-    pub fn getString(self: *const RegistryUtf8, allocator: std.mem.Allocator, subkey: []const u8, value_name: []const u8) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]u8 {
+    pub fn getString(self: *const RegistryWtf8, allocator: std.mem.Allocator, subkey: []const u8, value_name: []const u8) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]u8 {
-        const subkey_utf16le: [:0]const u16 = subkey_utf16le: {
+        const subkey_wtf16le: [:0]const u16 = subkey_wtf16le: {
-            var subkey_utf16le_buf: [RegistryUtf16Le.key_name_max_len]u16 = undefined;
+            var subkey_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const subkey_utf16le_len: usize = std.unicode.utf8ToUtf16Le(subkey_utf16le_buf[0..], subkey) catch unreachable;
+            const subkey_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(subkey_wtf16le_buf[0..], subkey) catch unreachable;
-            subkey_utf16le_buf[subkey_utf16le_len] = 0;
+            subkey_wtf16le_buf[subkey_wtf16le_len] = 0;
-            break :subkey_utf16le subkey_utf16le_buf[0..subkey_utf16le_len :0];
+            break :subkey_wtf16le subkey_wtf16le_buf[0..subkey_wtf16le_len :0];
         };
-        const value_name_utf16le: [:0]const u16 = value_name_utf16le: {
+        const value_name_wtf16le: [:0]const u16 = value_name_wtf16le: {
-            var value_name_utf16le_buf: [RegistryUtf16Le.value_name_max_len]u16 = undefined;
+            var value_name_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const value_name_utf16le_len: usize = std.unicode.utf8ToUtf16Le(value_name_utf16le_buf[0..], value_name) catch unreachable;
+            const value_name_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(value_name_wtf16le_buf[0..], value_name) catch unreachable;
-            value_name_utf16le_buf[value_name_utf16le_len] = 0;
+            value_name_wtf16le_buf[value_name_wtf16le_len] = 0;
-            break :value_name_utf16le value_name_utf16le_buf[0..value_name_utf16le_len :0];
+            break :value_name_wtf16le value_name_wtf16le_buf[0..value_name_wtf16le_len :0];
         };
-        const registry_utf16le = RegistryUtf16Le{ .key = self.key };
+        const registry_wtf16le = RegistryWtf16Le{ .key = self.key };
-        const value_utf16le = try registry_utf16le.getString(allocator, subkey_utf16le, value_name_utf16le);
+        const value_wtf16le = try registry_wtf16le.getString(allocator, subkey_wtf16le, value_name_wtf16le);
-        defer allocator.free(value_utf16le);
+        defer allocator.free(value_wtf16le);
-        const value_utf8: []u8 = std.unicode.utf16LeToUtf8Alloc(allocator, value_utf16le) catch |err| switch (err) {
+        const value_wtf8: []u8 = try std.unicode.wtf16LeToWtf8Alloc(allocator, value_wtf16le);
-            error.OutOfMemory => return error.OutOfMemory,
+        errdefer allocator.free(value_wtf8);
-            else => return error.StringNotFound,
-        };
-        errdefer allocator.free(value_utf8);
-        return value_utf8;
+        return value_wtf8;
     }
     /// Get DWORD (u32) from registry.
-    pub fn getDword(self: *const RegistryUtf8, subkey: []const u8, value_name: []const u8) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
+    pub fn getDword(self: *const RegistryWtf8, subkey: []const u8, value_name: []const u8) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
-        const subkey_utf16le: [:0]const u16 = subkey_utf16le: {
+        const subkey_wtf16le: [:0]const u16 = subkey_wtf16le: {
-            var subkey_utf16le_buf: [RegistryUtf16Le.key_name_max_len]u16 = undefined;
+            var subkey_wtf16le_buf: [RegistryWtf16Le.key_name_max_len]u16 = undefined;
-            const subkey_utf16le_len: usize = std.unicode.utf8ToUtf16Le(subkey_utf16le_buf[0..], subkey) catch unreachable;
+            const subkey_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(subkey_wtf16le_buf[0..], subkey) catch unreachable;
-            subkey_utf16le_buf[subkey_utf16le_len] = 0;
+            subkey_wtf16le_buf[subkey_wtf16le_len] = 0;
-            break :subkey_utf16le subkey_utf16le_buf[0..subkey_utf16le_len :0];
+            break :subkey_wtf16le subkey_wtf16le_buf[0..subkey_wtf16le_len :0];
         };
-        const value_name_utf16le: [:0]const u16 = value_name_utf16le: {
+        const value_name_wtf16le: [:0]const u16 = value_name_wtf16le: {
-            var value_name_utf16le_buf: [RegistryUtf16Le.value_name_max_len]u16 = undefined;
+            var value_name_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const value_name_utf16le_len: usize = std.unicode.utf8ToUtf16Le(value_name_utf16le_buf[0..], value_name) catch unreachable;
+            const value_name_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(value_name_wtf16le_buf[0..], value_name) catch unreachable;
-            value_name_utf16le_buf[value_name_utf16le_len] = 0;
+            value_name_wtf16le_buf[value_name_wtf16le_len] = 0;
-            break :value_name_utf16le value_name_utf16le_buf[0..value_name_utf16le_len :0];
+            break :value_name_wtf16le value_name_wtf16le_buf[0..value_name_wtf16le_len :0];
         };
-        const registry_utf16le = RegistryUtf16Le{ .key = self.key };
+        const registry_wtf16le = RegistryWtf16Le{ .key = self.key };
-        return try registry_utf16le.getDword(subkey_utf16le, value_name_utf16le);
+        return try registry_wtf16le.getDword(subkey_wtf16le, value_name_wtf16le);
     }
     /// Under private space with flags:
     /// KEY_QUERY_VALUE and KEY_ENUMERATE_SUB_KEYS.
     /// After finishing work, call `closeKey`.
-    pub fn loadFromPath(absolute_path: []const u8) error{KeyNotFound}!RegistryUtf8 {
+    pub fn loadFromPath(absolute_path: []const u8) error{KeyNotFound}!RegistryWtf8 {
-        const absolute_path_utf16le: [:0]const u16 = absolute_path_utf16le: {
+        const absolute_path_wtf16le: [:0]const u16 = absolute_path_wtf16le: {
-            var absolute_path_utf16le_buf: [RegistryUtf16Le.value_name_max_len]u16 = undefined;
+            var absolute_path_wtf16le_buf: [RegistryWtf16Le.value_name_max_len]u16 = undefined;
-            const absolute_path_utf16le_len: usize = std.unicode.utf8ToUtf16Le(absolute_path_utf16le_buf[0..], absolute_path) catch unreachable;
+            const absolute_path_wtf16le_len: usize = std.unicode.wtf8ToWtf16Le(absolute_path_wtf16le_buf[0..], absolute_path) catch unreachable;
-            absolute_path_utf16le_buf[absolute_path_utf16le_len] = 0;
+            absolute_path_wtf16le_buf[absolute_path_wtf16le_len] = 0;
-            break :absolute_path_utf16le absolute_path_utf16le_buf[0..absolute_path_utf16le_len :0];
+            break :absolute_path_wtf16le absolute_path_wtf16le_buf[0..absolute_path_wtf16le_len :0];
         };
-        const registry_utf16le = try RegistryUtf16Le.loadFromPath(absolute_path_utf16le);
+        const registry_wtf16le = try RegistryWtf16Le.loadFromPath(absolute_path_wtf16le);
-        return RegistryUtf8{ .key = registry_utf16le.key };
+        return RegistryWtf8{ .key = registry_wtf16le.key };
     }
 };
-const RegistryUtf16Le = struct {
+const RegistryWtf16Le = struct {
     key: windows.HKEY,
     /// Includes root key (f.e. HKEY_LOCAL_MACHINE).
 @@ -191,11 +188,11 @@ const RegistryUtf16Le = struct {
     /// Under HKEY_LOCAL_MACHINE with flags:
     /// KEY_QUERY_VALUE, KEY_WOW64_32KEY, and KEY_ENUMERATE_SUB_KEYS.
     /// After finishing work, call `closeKey`.
-    fn openKey(hkey: windows.HKEY, key_utf16le: [:0]const u16) error{KeyNotFound}!RegistryUtf16Le {
+    fn openKey(hkey: windows.HKEY, key_wtf16le: [:0]const u16) error{KeyNotFound}!RegistryWtf16Le {
         var key: windows.HKEY = undefined;
         const return_code_int: windows.HRESULT = windows.advapi32.RegOpenKeyExW(
             hkey,
-            key_utf16le,
+            key_wtf16le,
             0,
             windows.KEY_QUERY_VALUE | windows.KEY_WOW64_32KEY | windows.KEY_ENUMERATE_SUB_KEYS,
             &key,
 @@ -207,11 +204,11 @@ const RegistryUtf16Le = struct {
             else => return error.KeyNotFound,
         }
-        return RegistryUtf16Le{ .key = key };
+        return RegistryWtf16Le{ .key = key };
     }
     /// Closes key, after that usage is invalid
-    fn closeKey(self: *const RegistryUtf16Le) void {
+    fn closeKey(self: *const RegistryWtf16Le) void {
         const return_code_int: windows.HRESULT = windows.advapi32.RegCloseKey(self.key);
         const return_code: windows.Win32Error = @enumFromInt(return_code_int);
         switch (return_code) {
 @@ -221,25 +218,25 @@ const RegistryUtf16Le = struct {
     }
     /// Get string ([:0]const u16) from registry.
-    fn getString(self: *const RegistryUtf16Le, allocator: std.mem.Allocator, subkey_utf16le: [:0]const u16, value_name_utf16le: [:0]const u16) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]const u16 {
+    fn getString(self: *const RegistryWtf16Le, allocator: std.mem.Allocator, subkey_wtf16le: [:0]const u16, value_name_wtf16le: [:0]const u16) error{ OutOfMemory, ValueNameNotFound, NotAString, StringNotFound }![]const u16 {
         var actual_type: windows.ULONG = undefined;
         // Calculating length to allocate
-        var value_utf16le_buf_size: u32 = 0; // in bytes, including any terminating NUL character or characters.
+        var value_wtf16le_buf_size: u32 = 0; // in bytes, including any terminating NUL character or characters.
         var return_code_int: windows.HRESULT = windows.advapi32.RegGetValueW(
             self.key,
-            subkey_utf16le,
+            subkey_wtf16le,
-            value_name_utf16le,
+            value_name_wtf16le,
             RRF.RT_REG_SZ,
             &actual_type,
             null,
-            &value_utf16le_buf_size,
+            &value_wtf16le_buf_size,
         );
         // Check returned code and type
         var return_code: windows.Win32Error = @enumFromInt(return_code_int);
         switch (return_code) {
-            .SUCCESS => std.debug.assert(value_utf16le_buf_size != 0),
+            .SUCCESS => std.debug.assert(value_wtf16le_buf_size != 0),
             .MORE_DATA => unreachable, // We are only reading length
             .FILE_NOT_FOUND => return error.ValueNameNotFound,
             .INVALID_PARAMETER => unreachable, // We didn't combine RRF.SUBKEY_WOW6464KEY and RRF.SUBKEY_WOW6432KEY
 @@ -250,17 +247,17 @@ const RegistryUtf16Le = struct {
             else => return error.NotAString,
         }
-        const value_utf16le_buf: []u16 = try allocator.alloc(u16, std.math.divCeil(u32, value_utf16le_buf_size, 2) catch unreachable);
+        const value_wtf16le_buf: []u16 = try allocator.alloc(u16, std.math.divCeil(u32, value_wtf16le_buf_size, 2) catch unreachable);
-        errdefer allocator.free(value_utf16le_buf);
+        errdefer allocator.free(value_wtf16le_buf);
         return_code_int = windows.advapi32.RegGetValueW(
             self.key,
-            subkey_utf16le,
+            subkey_wtf16le,
-            value_name_utf16le,
+            value_name_wtf16le,
             RRF.RT_REG_SZ,
             &actual_type,
-            value_utf16le_buf.ptr,
+            value_wtf16le_buf.ptr,
-            &value_utf16le_buf_size,
+            &value_wtf16le_buf_size,
         );
         // Check returned code and (just in case) type again.
 @@ -277,28 +274,28 @@ const RegistryUtf16Le = struct {
             else => return error.NotAString,
         }
-        const value_utf16le: []const u16 = value_utf16le: {
+        const value_wtf16le: []const u16 = value_wtf16le: {
             // note(bratishkaerik): somehow returned value in `buf_len` is overestimated by Windows and contains extra space
             // we will just search for zero termination and forget length
             // Windows sure is strange
-            const value_utf16le_overestimated: [*:0]const u16 = @ptrCast(value_utf16le_buf.ptr);
+            const value_wtf16le_overestimated: [*:0]const u16 = @ptrCast(value_wtf16le_buf.ptr);
-            break :value_utf16le std.mem.span(value_utf16le_overestimated);
+            break :value_wtf16le std.mem.span(value_wtf16le_overestimated);
         };
-        _ = allocator.resize(value_utf16le_buf, value_utf16le.len);
+        _ = allocator.resize(value_wtf16le_buf, value_wtf16le.len);
-        return value_utf16le;
+        return value_wtf16le;
     }
     /// Get DWORD (u32) from registry.
-    fn getDword(self: *const RegistryUtf16Le, subkey_utf16le: [:0]const u16, value_name_utf16le: [:0]const u16) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
+    fn getDword(self: *const RegistryWtf16Le, subkey_wtf16le: [:0]const u16, value_name_wtf16le: [:0]const u16) error{ ValueNameNotFound, NotADword, DwordTooLong, DwordNotFound }!u32 {
         var actual_type: windows.ULONG = undefined;
         var reg_size: u32 = @sizeOf(u32);
         var reg_value: u32 = 0;
         const return_code_int: windows.HRESULT = windows.advapi32.RegGetValueW(
             self.key,
-            subkey_utf16le,
+            subkey_wtf16le,
-            value_name_utf16le,
+            value_name_wtf16le,
             RRF.RT_REG_DWORD,
             &actual_type,
             &reg_value,
 @@ -324,11 +321,11 @@ const RegistryUtf16Le = struct {
     /// Under private space with flags:
     /// KEY_QUERY_VALUE and KEY_ENUMERATE_SUB_KEYS.
     /// After finishing work, call `closeKey`.
-    fn loadFromPath(absolute_path_as_utf16le: [:0]const u16) error{KeyNotFound}!RegistryUtf16Le {
+    fn loadFromPath(absolute_path_as_wtf16le: [:0]const u16) error{KeyNotFound}!RegistryWtf16Le {
         var key: windows.HKEY = undefined;
         const return_code_int: windows.HRESULT = std.os.windows.advapi32.RegLoadAppKeyW(
-            absolute_path_as_utf16le,
+            absolute_path_as_wtf16le,
             &key,
             windows.KEY_QUERY_VALUE | windows.KEY_ENUMERATE_SUB_KEYS,
             0,
 @@ -340,7 +337,7 @@ const RegistryUtf16Le = struct {
             else => return error.KeyNotFound,
         }
-        return RegistryUtf16Le{ .key = key };
+        return RegistryWtf16Le{ .key = key };
     }
 };
 @@ -352,7 +349,7 @@ pub const Windows10Sdk = struct {
     /// Caller owns the result's fields.
     /// After finishing work, call `free(allocator)`.
     fn find(allocator: std.mem.Allocator) error{ OutOfMemory, Windows10SdkNotFound, PathTooLong, VersionTooLong }!Windows10Sdk {
-        const v10_key = RegistryUtf8.openKey(windows.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0") catch |err| switch (err) {
+        const v10_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0") catch |err| switch (err) {
             error.KeyNotFound => return error.Windows10SdkNotFound,
         };
         defer v10_key.closeKey();
 @@ -413,11 +410,11 @@ pub const Windows10Sdk = struct {
     /// Check whether this version is enumerated in registry.
     fn isValidVersion(windows10sdk: *const Windows10Sdk) bool {
         var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        const reg_query_as_utf8 = std.fmt.bufPrint(buf[0..], "{s}\\{s}\\Installed Options", .{ WINDOWS_KIT_REG_KEY, windows10sdk.version }) catch |err| switch (err) {
+        const reg_query_as_wtf8 = std.fmt.bufPrint(buf[0..], "{s}\\{s}\\Installed Options", .{ WINDOWS_KIT_REG_KEY, windows10sdk.version }) catch |err| switch (err) {
             error.NoSpaceLeft => return false,
         };
-        const options_key = RegistryUtf8.openKey(windows.HKEY_LOCAL_MACHINE, reg_query_as_utf8) catch |err| switch (err) {
+        const options_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, reg_query_as_wtf8) catch |err| switch (err) {
             error.KeyNotFound => return false,
         };
         defer options_key.closeKey();
 @@ -447,7 +444,7 @@ pub const Windows81Sdk = struct {
     /// Find path and version of Windows 8.1 SDK.
     /// Caller owns the result's fields.
     /// After finishing work, call `free(allocator)`.
-    fn find(allocator: std.mem.Allocator, roots_key: *const RegistryUtf8) error{ OutOfMemory, Windows81SdkNotFound, PathTooLong, VersionTooLong }!Windows81Sdk {
+    fn find(allocator: std.mem.Allocator, roots_key: *const RegistryWtf8) error{ OutOfMemory, Windows81SdkNotFound, PathTooLong, VersionTooLong }!Windows81Sdk {
         const path: []const u8 = path81: {
             const path_maybe_with_trailing_slash = roots_key.getString(allocator, "", "KitsRoot81") catch |err| switch (err) {
                 error.NotAString => return error.Windows81SdkNotFound,
 @@ -523,7 +520,7 @@ pub const ZigWindowsSDK = struct {
         if (builtin.os.tag != .windows) return error.NotFound;
         //note(dimenus): If this key doesn't exist, neither the Win 8 SDK nor the Win 10 SDK is installed
-        const roots_key = RegistryUtf8.openKey(windows.HKEY_LOCAL_MACHINE, WINDOWS_KIT_REG_KEY) catch |err| switch (err) {
+        const roots_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, WINDOWS_KIT_REG_KEY) catch |err| switch (err) {
             error.KeyNotFound => return error.NotFound,
         };
         defer roots_key.closeKey();
 @@ -583,7 +580,7 @@ pub const ZigWindowsSDK = struct {
 const MsvcLibDir = struct {
     fn findInstancesDirViaCLSID(allocator: std.mem.Allocator) error{ OutOfMemory, PathNotFound }!std.fs.Dir {
         const setup_configuration_clsid = "{177f0c4a-1cd3-4de7-a32c-71dbbb9fa36d}";
-        const setup_config_key = RegistryUtf8.openKey(windows.HKEY_CLASSES_ROOT, "CLSID\\" ++ setup_configuration_clsid) catch |err| switch (err) {
+        const setup_config_key = RegistryWtf8.openKey(windows.HKEY_CLASSES_ROOT, "CLSID\\" ++ setup_configuration_clsid) catch |err| switch (err) {
             error.KeyNotFound => return error.PathNotFound,
         };
         defer setup_config_key.closeKey();
 @@ -805,13 +802,13 @@ const MsvcLibDir = struct {
             for (vs_versions) |vs_version| allocator.free(vs_version);
             allocator.free(vs_versions);
         }
-        var config_subkey_buf: [RegistryUtf16Le.key_name_max_len * 2]u8 = undefined;
+        var config_subkey_buf: [RegistryWtf16Le.key_name_max_len * 2]u8 = undefined;
         const source_directories: []const u8 = source_directories: for (vs_versions) |vs_version| {
             const privateregistry_absolute_path = std.fs.path.join(allocator, &.{ visualstudio_folder_path, vs_version, "privateregistry.bin" }) catch continue;
             defer allocator.free(privateregistry_absolute_path);
             if (!std.fs.path.isAbsolute(privateregistry_absolute_path)) continue;
-            const visualstudio_registry = RegistryUtf8.loadFromPath(privateregistry_absolute_path) catch continue;
+            const visualstudio_registry = RegistryWtf8.loadFromPath(privateregistry_absolute_path) catch continue;
             defer visualstudio_registry.closeKey();
             const config_subkey = std.fmt.bufPrint(config_subkey_buf[0..], "Software\\Microsoft\\VisualStudio\\{s}_Config", .{vs_version}) catch unreachable;
 @@ -894,7 +891,7 @@ const MsvcLibDir = struct {
                 }
             }
-            const vs7_key = RegistryUtf8.openKey(windows.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7") catch return error.PathNotFound;
+            const vs7_key = RegistryWtf8.openKey(windows.HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7") catch return error.PathNotFound;
             defer vs7_key.closeKey();
             try_vs7_key: {
                 const path_maybe_with_trailing_slash = vs7_key.getString(allocator, "", "14.0") catch |err| switch (err) {

...	@@ -639,7 +639,8 @@ pub fn abiAndDynamicLinkerFromFile(	...	@@ -639,7 +639,8 @@ pub fn abiAndDynamicLinkerFromFile(
639	var link_buf: [std.os.PATH_MAX]u8 = undefined;	639	var link_buf: [std.os.PATH_MAX]u8 = undefined;
640	const link_name = std.os.readlink(dl_path, &link_buf) catch \|err\| switch (err) {	640	const link_name = std.os.readlink(dl_path, &link_buf) catch \|err\| switch (err) {
641	error.NameTooLong => unreachable,	641	error.NameTooLong => unreachable,
642	error.InvalidUtf8 => unreachable, // Windows only	642	error.InvalidUtf8 => unreachable, // WASI only
		643	error.InvalidWtf8 => unreachable, // Windows only
643	error.BadPathName => unreachable, // Windows only	644	error.BadPathName => unreachable, // Windows only
644	error.UnsupportedReparsePointType => unreachable, // Windows only	645	error.UnsupportedReparsePointType => unreachable, // Windows only
645	error.NetworkNotFound => unreachable, // Windows only	646	error.NetworkNotFound => unreachable, // Windows only
...	@@ -730,7 +731,8 @@ test glibcVerFromLinkName {	...	@@ -730,7 +731,8 @@ test glibcVerFromLinkName {
730	fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {	731	fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {
731	var dir = fs.cwd().openDir(rpath, .{}) catch \|err\| switch (err) {	732	var dir = fs.cwd().openDir(rpath, .{}) catch \|err\| switch (err) {
732	error.NameTooLong => unreachable,	733	error.NameTooLong => unreachable,
733	error.InvalidUtf8 => unreachable,	734	error.InvalidUtf8 => unreachable, // WASI only
		735	error.InvalidWtf8 => unreachable, // Windows-only
734	error.BadPathName => unreachable,	736	error.BadPathName => unreachable,
735	error.DeviceBusy => unreachable,	737	error.DeviceBusy => unreachable,
736	error.NetworkNotFound => unreachable, // Windows-only	738	error.NetworkNotFound => unreachable, // Windows-only
...	@@ -761,7 +763,8 @@ fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {	...	@@ -761,7 +763,8 @@ fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {
761	const glibc_so_basename = "libc.so.6";	763	const glibc_so_basename = "libc.so.6";
762	var f = dir.openFile(glibc_so_basename, .{}) catch \|err\| switch (err) {	764	var f = dir.openFile(glibc_so_basename, .{}) catch \|err\| switch (err) {
763	error.NameTooLong => unreachable,	765	error.NameTooLong => unreachable,
764	error.InvalidUtf8 => unreachable, // Windows only	766	error.InvalidUtf8 => unreachable, // WASI only
		767	error.InvalidWtf8 => unreachable, // Windows only
765	error.BadPathName => unreachable, // Windows only	768	error.BadPathName => unreachable, // Windows only
766	error.PipeBusy => unreachable, // Windows-only	769	error.PipeBusy => unreachable, // Windows-only
767	error.SharingViolation => unreachable, // Windows-only	770	error.SharingViolation => unreachable, // Windows-only
...	@@ -998,7 +1001,8 @@ fn detectAbiAndDynamicLinker(	...	@@ -998,7 +1001,8 @@ fn detectAbiAndDynamicLinker(
998	error.NameTooLong => unreachable,	1001	error.NameTooLong => unreachable,
999	error.PathAlreadyExists => unreachable,	1002	error.PathAlreadyExists => unreachable,
1000	error.SharingViolation => unreachable,	1003	error.SharingViolation => unreachable,
1001	error.InvalidUtf8 => unreachable,	1004	error.InvalidUtf8 => unreachable, // WASI only
		1005	error.InvalidWtf8 => unreachable, // Windows only
1002	error.BadPathName => unreachable,	1006	error.BadPathName => unreachable,
1003	error.PipeBusy => unreachable,	1007	error.PipeBusy => unreachable,
1004	error.FileLocksNotSupported => unreachable,	1008	error.FileLocksNotSupported => unreachable,