Implement writeAsBytes for Windows (#210)

Author: brianquinlan

.github/workflows/io_file.yml

@@ -72,8 +72,10 @@ jobs:
         with:
           sdk: ${{ matrix.sdk }}
       - run: dart pub get
-      - name: 🪑 Run benchmarks
+      - name: 🪑 Run Read Benchmarks
         run: dart run benchmarks/read_as_bytes.dart
+      - name: 🪑 Run Write Benchmarks
+        run: dart run benchmarks/write_as_bytes.dart
 
   ios-vm-test:
     runs-on: macos-latest

pkgs/io_file/benchmarks/write_as_bytes.dart

@@ -0,0 +1,63 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:io_file/io_file.dart';
+
+class WriteAsBytesBenchmark extends BenchmarkBase {
+  late Directory dir;
+  late String path;
+  final Uint8List data;
+
+  WriteAsBytesBenchmark(super.name, int size) : data = Uint8List(size);
+
+  @override
+  void setup() {
+    dir = Directory.systemTemp.createTempSync('bench');
+    path = '${dir.path}/file';
+  }
+
+  @override
+  void teardown() {
+    dir.deleteSync(recursive: true);
+  }
+}
+
+class IOFilesWriteAsBytesBenchmark extends WriteAsBytesBenchmark {
+  IOFilesWriteAsBytesBenchmark(int size)
+    : super('IOFilesWriteAsBytesBenchmark($size)', size);
+
+  static void main(int size) {
+    IOFilesWriteAsBytesBenchmark(size).report();
+  }
+
+  @override
+  void run() {
+    fileSystem.writeAsBytes(path, data, WriteMode.truncateExisting);
+  }
+}
+
+class DartIOWriteAsBytesBenchmark extends WriteAsBytesBenchmark {
+  DartIOWriteAsBytesBenchmark(int size)
+    : super('DartIOWriteAsBytesBenchmark($size)', size);
+
+  static void main(int size) {
+    DartIOWriteAsBytesBenchmark(size).report();
+  }
+
+  @override
+  void run() {
+    File(path).writeAsBytesSync(data);
+  }
+}
+
+void main() {
+  for (var size in [0, 1024, 64 * 1024, 1024 * 1024, 64 * 1024 * 1024]) {
+    DartIOWriteAsBytesBenchmark.main(size);
+    IOFilesWriteAsBytesBenchmark.main(size);
+  }
+}

pkgs/io_file/lib/src/file_system.dart

@@ -56,6 +56,12 @@ base class FileSystem {
   }
 
   /// Write the given bytes to a file.
+  ///
+  /// If `path` is a broken symlink and `mode` is [WriteMode.failExisting]:
+  ///
+  /// - On Windows, the target of the symlink is created, using `data` as its
+  ///   contents.
+  /// - On POSIX, [writeAsBytes] throws `PathExistsException`.
   void writeAsBytes(
     String path,
     Uint8List data, [

pkgs/io_file/lib/src/internal_constants.dart

@@ -2,21 +2,33 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// The maximum number of bytes to read in a single call to `read`.
-//
-// On macOS, it is an error to call
-// `read/_read(fildes, buf, nbyte)` with `nbyte >= INT_MAX`.
-//
-// The POSIX specification states that the behavior of `read` is
-// implementation-defined if `nbyte > SSIZE_MAX`. On Linux, the `read` will
-// transfer at most 0x7ffff000 bytes and return the number of bytes actually.
-// transfered.
-//
-// A smaller value has the advantage of making vm-service clients
-// (e.g. debugger) more responsive.
-//
-// A bigger value reduces the number of system calls.
+/// The maximum number of bytes to read in a single call to `read`.
+///
+/// On macOS, it is an error to call
+/// `read/_read(fildes, buf, nbyte)` with `nbyte >= INT_MAX`.
+///
+/// The POSIX specification states that the behavior of `read` is
+/// implementation-defined if `nbyte > SSIZE_MAX`. On Linux, the `read` will
+/// transfer at most 0x7ffff000 bytes and return the number of bytes actually.
+/// transfered.
+///
+//// A smaller value has the advantage of making vm-service clients
+/// (e.g. debugger) more responsive.
+///
+/// A bigger value reduces the number of system calls.
 const int maxReadSize = 16 * 1024 * 1024; // 16MB.
 
-// If the size of a file is unknown, read in blocks of this size.
+/// If the size of a file is unknown, read in blocks of this size.
 const int blockSize = 64 * 1024;
+
+/// The maximum number of bytes to read in a single call to `read`.
+///
+/// `write` on FreeBSD returns `EINVAL` if nbytes is greater than
+/// `INT_MAX`.
+/// See https://man.freebsd.org/cgi/man.cgi?write(2)
+///
+/// A smaller value has the advantage of making vm-service clients
+/// (e.g. debugger) more responsive.
+///
+/// A bigger value reduces the number of system calls.
+const int maxWriteSize = 16 * 1024 * 1024; // 16MB.

pkgs/io_file/lib/src/vm_posix_file_system.dart

@@ -13,8 +13,6 @@ import 'package:stdlibc/stdlibc.dart' as stdlibc;
 import 'file_system.dart';
 import 'internal_constants.dart';
 
-const _maxInt32 = 2147483647;
-
 /// The default `mode` to use with `open` calls that may create a file.
 const _defaultMode = 438; // => 0666 => rw-rw-rw-
 
@@ -179,15 +177,10 @@ base class PosixFileSystem extends FileSystem {
         buffer.asTypedList(data.length).setAll(0, data);
         var remaining = data.length;
 
-        // `write` on FreeBSD returns `EINVAL` if nbytes is greater than
-        // `INT_MAX`.
-        // See https://man.freebsd.org/cgi/man.cgi?write(2)
-        final maxWriteSize =
-            (io.Platform.isIOS || io.Platform.isMacOS) ? _maxInt32 : remaining;
-
         while (remaining > 0) {
           final w = _tempFailureRetry(
-            () => write(fd, buffer, min(remaining, maxWriteSize)),
+            () =>
+                write(fd, buffer, min(remaining, min(maxWriteSize, remaining))),
           );
           if (w == -1) {
             final errno = stdlibc.errno;

pkgs/io_file/lib/src/vm_windows_file_system.dart

@@ -195,4 +195,68 @@ base class WindowsFileSystem extends FileSystem {
       rethrow;
     }
   }
+
+  @override
+  void writeAsBytes(
+    String path,
+    Uint8List data, [
+    WriteMode mode = WriteMode.failExisting,
+  ]) => using((arena) {
+    // Calling `GetLastError` for the first time causes the `GetLastError`
+    // symbol to be loaded, which resets `GetLastError`. So make a harmless
+    // call before the value is needed.
+    win32.GetLastError();
+
+    var createFlags = 0;
+    createFlags |= switch (mode) {
+      WriteMode.appendExisting => win32.OPEN_ALWAYS,
+      WriteMode.failExisting => win32.CREATE_NEW,
+      WriteMode.truncateExisting => win32.CREATE_ALWAYS,
+      _ => throw ArgumentError.value(mode, 'invalid write mode'),
+    };
+
+    final f = win32.CreateFile(
+      path.toNativeUtf16(),
+      mode == WriteMode.appendExisting
+          ? win32.FILE_APPEND_DATA
+          : win32.FILE_GENERIC_WRITE,
+      0,
+      nullptr,
+      createFlags,
+      win32.FILE_ATTRIBUTE_NORMAL,
+      0,
+    );
+    if (f == win32.INVALID_HANDLE_VALUE) {
+      final errorCode = win32.GetLastError();
+      throw _getError(errorCode, 'open failed', path);
+    }
+
+    try {
+      // TODO(brianquinlan): Remove this copy when typed data pointers are
+      // available for non-leaf calls.
+      var buffer = arena<Uint8>(data.length);
+      buffer.asTypedList(data.length).setAll(0, data);
+      final bytesWritten = arena<win32.DWORD>();
+      var remaining = data.length;
+
+      while (remaining > 0) {
+        if (win32.WriteFile(
+              f,
+              buffer.cast(),
+              min(maxWriteSize, remaining),
+              bytesWritten,
+              nullptr,
+            ) ==
+            win32.FALSE) {
+          final errorCode = win32.GetLastError();
+          throw _getError(errorCode, 'write failed', path);
+        }
+
+        remaining -= bytesWritten.value;
+        buffer += bytesWritten.value;
+      }
+    } finally {
+      win32.CloseHandle(f);
+    }
+  });
 }

pkgs/io_file/test/write_as_bytes_test.dart

@@ -2,7 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-@TestOn('posix')
+@TestOn('vm')
 library;
 
 import 'dart:io';
@@ -11,6 +11,7 @@ import 'dart:typed_data';
 import 'package:io_file/io_file.dart';
 import 'package:stdlibc/stdlibc.dart' as stdlibc;
 import 'package:test/test.dart';
+import 'package:win32/win32.dart' as win32;
 
 import 'test_utils.dart';
 
@@ -34,7 +35,11 @@ void main() {
         throwsA(
           isA<FileSystemException>()
               .having((e) => e.message, 'message', 'open failed')
-              .having((e) => e.osError?.errorCode, 'errorCode', stdlibc.EISDIR)
+              .having(
+                (e) => e.osError?.errorCode,
+                'errorCode',
+                Platform.isWindows ? win32.ERROR_ACCESS_DENIED : stdlibc.EISDIR,
+              )
               .having((e) => e.path, 'path', tmp),
         ),
       );
@@ -61,23 +66,39 @@ void main() {
         Link(symlinkPath).createSync(filePath);
         File(filePath).deleteSync();
 
-        expect(
-          () => fileSystem.writeAsBytes(
+        if (Platform.isWindows) {
+          // Windows considers a broken symlink to not be an existing file.
+          fileSystem.writeAsBytes(
             symlinkPath,
             Uint8List.fromList(data),
             WriteMode.failExisting,
-          ),
-          throwsA(
-            isA<PathExistsException>()
-                .having((e) => e.message, 'message', 'open failed')
-                .having(
-                  (e) => e.osError?.errorCode,
-                  'errorCode',
-                  stdlibc.EEXIST,
-                )
-                .having((e) => e.path, 'path', symlinkPath),
-          ),
-        );
+          );
+
+          // Should write at the symlink target, which should also mean that the
+          // symlink is no longer broken.
+          expect(fileSystem.readAsBytes(symlinkPath), data);
+          expect(fileSystem.readAsBytes(filePath), data);
+        } else {
+          expect(
+            () => fileSystem.writeAsBytes(
+              symlinkPath,
+              Uint8List.fromList(data),
+              WriteMode.failExisting,
+            ),
+            throwsA(
+              isA<PathExistsException>()
+                  .having((e) => e.message, 'message', 'open failed')
+                  .having(
+                    (e) => e.osError?.errorCode,
+                    'errorCode',
+                    Platform.isWindows
+                        ? win32.ERROR_FILE_EXISTS
+                        : stdlibc.EEXIST,
+                  )
+                  .having((e) => e.path, 'path', symlinkPath),
+            ),
+          );
+        }
       });
       test('truncateExisting', () {
         final filePath = '$tmp/file1';
@@ -165,7 +186,7 @@ void main() {
                 .having(
                   (e) => e.osError?.errorCode,
                   'errorCode',
-                  stdlibc.EEXIST,
+                  Platform.isWindows ? win32.ERROR_FILE_EXISTS : stdlibc.EEXIST,
                 )
                 .having((e) => e.path, 'path', path),
           ),
@@ -205,7 +226,7 @@ void main() {
       }
 
       test('Write very large file', () {
-        // FreeBSD cannot write more than INT_MAX at once.
+        // FreeBSD/Windows cannot write more than INT_MAX at once.
         final data = randomUint8List(1 << 31 + 1);
         final path = '$tmp/file';