std.fs: support Lock.none on Windows

lib/std/fs/File.zig

@@ -1617,14 +1617,23 @@ pub const LockError = error{
 /// A process may hold only one type of lock (shared or exclusive) on
 /// a file. When a process terminates in any way, the lock is released.
 ///
-/// Assumes the file is unlocked.
+/// Assumes the file is unlocked, or in the case of Lock.none, locked.
 ///
 /// TODO: integrate with async I/O
 pub fn lock(file: File, l: Lock) LockError!void {
     if (is_windows) {
         var io_status_block: windows.IO_STATUS_BLOCK = undefined;
         const exclusive = switch (l) {
-            .none => return,
+            .none => return windows.UnlockFile(
+                file.handle,
+                &io_status_block,
+                &range_off,
+                &range_len,
+                null,
+            ) catch |err| switch (err) {
+                error.RangeNotLocked => unreachable, // The file is assumed to be locked.
+                error.Unexpected => return error.Unexpected,
+            },
             .shared => false,
             .exclusive => true,
         };
@@ -1666,7 +1675,7 @@ pub fn unlock(file: File) void {
             &range_len,
             null,
         ) catch |err| switch (err) {
-            error.RangeNotLocked => unreachable, // Function assumes unlocked.
+            error.RangeNotLocked => unreachable, // Function assumes locked.
             error.Unexpected => unreachable, // Resource deallocation must succeed.
         };
     } else {
@@ -1684,14 +1693,27 @@ pub fn unlock(file: File) void {
 /// A process may hold only one type of lock (shared or exclusive) on
 /// a file. When a process terminates in any way, the lock is released.
 ///
-/// Assumes the file is unlocked.
+/// Assumes the file is unlocked, or in the case of Lock.none, locked.
 ///
 /// TODO: integrate with async I/O
 pub fn tryLock(file: File, l: Lock) LockError!bool {
     if (is_windows) {
         var io_status_block: windows.IO_STATUS_BLOCK = undefined;
         const exclusive = switch (l) {
-            .none => return,
+            .none => {
+                windows.UnlockFile(
+                    file.handle,
+                    &io_status_block,
+                    &range_off,
+                    &range_len,
+                    null,
+                ) catch |err| switch (err) {
+                    error.RangeNotLocked => unreachable, // The file is assumed to be locked.
+                    error.Unexpected => return error.Unexpected,
+                };
+
+                return true;
+            },
             .shared => false,
             .exclusive => true,
         };
@@ -1758,7 +1780,7 @@ pub fn downgradeLock(file: File) LockError!void {
             null,
         ) catch |err| switch (err) {
             error.RangeNotLocked => unreachable, // File was not locked.
-            error.Unexpected => unreachable, // Resource deallocation must succeed.
+            error.Unexpected => return error.Unexpected,
         };
     } else {
         return posix.flock(file.handle, posix.LOCK.SH | posix.LOCK.NB) catch |err| switch (err) {

lib/std/fs/test.zig

@@ -1923,6 +1923,31 @@ test "File.PermissionsUnix" {
     try testing.expect(!permissions_unix.unixHas(.other, .execute));
 }
 
+test "use Lock.none to unlock files" {
+    if (native_os == .wasi) return error.SkipZigTest;
+
+    var tmp = tmpDir(.{});
+    defer tmp.cleanup();
+
+    // Create a locked file.
+    const test_file = try tmp.dir.createFile("test_file", .{ .lock = .exclusive, .lock_nonblocking = true });
+    defer test_file.close();
+
+    // Attempt to unlock the file via fs.lock with Lock.none.
+    try File.lock(test_file, .none);
+
+    // Attempt to open the file now that it should be unlocked.
+    const test_file2 = try tmp.dir.openFile("test_file", .{ .lock = .exclusive, .lock_nonblocking = true });
+    defer test_file2.close();
+
+    // Make sure Lock.none works with tryLock as well.
+    try testing.expect(try File.tryLock(test_file2, .none));
+
+    // Attempt to open the file since it should be unlocked again.
+    const test_file3 = try tmp.dir.openFile("test_file", .{});
+    test_file3.close();
+}
+
 test "delete a read-only file on windows" {
     if (native_os != .windows)
         return error.SkipZigTest;

lib/std/os/windows.zig

@@ -2054,7 +2054,7 @@ pub fn LockFile(
     Key: ?*ULONG,
     FailImmediately: BOOLEAN,
     ExclusiveLock: BOOLEAN,
-) !void {
+) LockFileError!void {
     const rc = ntdll.NtLockFile(
         FileHandle,
         Event,
@@ -2086,7 +2086,7 @@ pub fn UnlockFile(
     ByteOffset: *const LARGE_INTEGER,
     Length: *const LARGE_INTEGER,
     Key: ?*ULONG,
-) !void {
+) UnlockFileError!void {
     const rc = ntdll.NtUnlockFile(FileHandle, IoStatusBlock, ByteOffset, Length, Key);
     switch (rc) {
         .SUCCESS => return,