Add back write caching.

Author: davidmorgan

_test_common/lib/runner_asset_writer_spy.dart

@@ -23,7 +23,4 @@ class RunnerAssetWriterSpy extends AssetWriterSpy implements RunnerAssetWriter {
 
   @override
   Future<void> deleteDirectory(AssetId id) => _delegate.deleteDirectory(id);
-
-  @override
-  Future<void> completeBuild() async {}
 }

build/lib/src/state/filesystem_cache.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
+import '../../build.dart';
 import '../asset/id.dart';
 import 'lru_cache.dart';
 
@@ -16,6 +17,9 @@ abstract interface class FilesystemCache {
   /// Clears all [ids] from all caches.
   void invalidate(Iterable<AssetId> ids);
 
+  /// Flushes pending writes and deletes.
+  void flush();
+
   /// Whether [id] exists.
   ///
   /// Returns a cached result if available, or caches and returns `ifAbsent()`.
@@ -26,6 +30,17 @@ abstract interface class FilesystemCache {
   /// Returns a cached result if available, or caches and returns `ifAbsent()`.
   Uint8List readAsBytes(AssetId id, {required Uint8List Function() ifAbsent});
 
+  /// Writes [contents] to [id].
+  ///
+  /// [writer] is a function that does the actual write. If this cache does
+  /// write caching, it is not called until [flush], and might not be called at
+  /// all if another write to the same asset happens first.
+  void writeAsBytes(
+    AssetId id,
+    List<int> contents, {
+    required void Function() writer,
+  });
+
   /// Reads [id] as a `String`.
   ///
   /// Returns a cached result if available, or caches and returns `ifAbsent()`.
@@ -34,6 +49,25 @@ abstract interface class FilesystemCache {
     Encoding encoding = utf8,
     required Uint8List Function() ifAbsent,
   });
+
+  /// Writes [contents] to [id].
+  ///
+  /// [writer] is a function that does the actual write. If this cache does
+  /// write caching, it is not called until [flush], and might not be called at
+  /// all if another write to the same asset happens first.
+  void writeAsString(
+    AssetId id,
+    String contents, {
+    Encoding encoding = utf8,
+    required void Function() writer,
+  });
+
+  /// Deletes [id].
+  ///
+  /// [deleter] is a function that does the actual write. If this cache does
+  /// write caching, it is not called until [flush], and might not be called at
+  /// all if another write to the same asset happens first.
+  void delete(AssetId id, {required void Function() deleter});
 }
 
 /// [FilesystemCache] that always reads from the underlying source.
@@ -43,19 +77,40 @@ class PassthroughFilesystemCache implements FilesystemCache {
   @override
   Future<void> invalidate(Iterable<AssetId> ids) async {}
 
+  @override
+  void flush() {}
+
   @override
   bool exists(AssetId id, {required bool Function() ifAbsent}) => ifAbsent();
 
   @override
   Uint8List readAsBytes(AssetId id, {required Uint8List Function() ifAbsent}) =>
       ifAbsent();
 
+  @override
+  void writeAsBytes(
+    AssetId id,
+    List<int> contents, {
+    required void Function() writer,
+  }) => writer();
+
   @override
   String readAsString(
     AssetId id, {
     Encoding encoding = utf8,
     required Uint8List Function() ifAbsent,
   }) => encoding.decode(ifAbsent());
+
+  @override
+  void writeAsString(
+    AssetId id,
+    String contents, {
+    Encoding encoding = utf8,
+    required void Function() writer,
+  }) => writer();
+
+  @override
+  void delete(AssetId id, {required void Function() deleter}) => deleter();
 }
 
 /// [FilesystemCache] that stores data in memory.
@@ -83,8 +138,13 @@ class InMemoryFilesystemCache implements FilesystemCache {
     (value) => value.length,
   );
 
+  final _pendingWrites = <AssetId, _PendingWrite>{};
+
   @override
   Future<void> invalidate(Iterable<AssetId> ids) async {
+    if (_pendingWrites.isNotEmpty) {
+      throw StateError("Can't invalidate while there are pending writes.");
+    }
     for (var id in ids) {
       _existsCache.remove(id);
       _bytesContentCache.remove(id);
@@ -93,11 +153,30 @@ class InMemoryFilesystemCache implements FilesystemCache {
   }
 
   @override
-  bool exists(AssetId id, {required bool Function() ifAbsent}) =>
-      _existsCache.putIfAbsent(id, ifAbsent);
+  void flush() {
+    for (final write in _pendingWrites.values) {
+      write.writer();
+    }
+    _pendingWrites.clear();
+  }
+
+  @override
+  bool exists(AssetId id, {required bool Function() ifAbsent}) {
+    final maybePendingWrite = _pendingWrites[id];
+    if (maybePendingWrite != null) {
+      return !maybePendingWrite.isDelete;
+    }
+    return _existsCache.putIfAbsent(id, ifAbsent);
+  }
 
   @override
   Uint8List readAsBytes(AssetId id, {required Uint8List Function() ifAbsent}) {
+    final maybePendingWrite = _pendingWrites[id];
+    if (maybePendingWrite != null) {
+      // Throws if it's a delete; callers should check [exists] before reading.
+      return maybePendingWrite.bytes!;
+    }
+
     final maybeResult = _bytesContentCache[id];
     if (maybeResult != null) return maybeResult;
 
@@ -106,6 +185,24 @@ class InMemoryFilesystemCache implements FilesystemCache {
     return result;
   }
 
+  @override
+  @override
+  void writeAsBytes(
+    AssetId id,
+    List<int> contents, {
+    required void Function() writer,
+  }) {
+    _stringContentCache.remove(id);
+    final uint8ListContents =
+        contents is Uint8List ? contents : Uint8List.fromList(contents);
+    _bytesContentCache[id] = uint8ListContents;
+    _existsCache[id] = true;
+    _pendingWrites[id] = _PendingWrite(
+      writer: writer,
+      bytes: uint8ListContents,
+    );
+  }
+
   @override
   String readAsString(
     AssetId id, {
@@ -117,9 +214,19 @@ class InMemoryFilesystemCache implements FilesystemCache {
       return encoding.decode(bytes);
     }
 
+    // Check _stringContentCache first to use it as a cache for conversion of
+    // bytes from _pendingWrites.
     final maybeResult = _stringContentCache[id];
     if (maybeResult != null) return maybeResult;
 
+    final maybePendingWrite = _pendingWrites[id];
+    if (maybePendingWrite != null) {
+      // Throws if it's a delete; callers should check [exists] before reading.
+      final converted = utf8.decode(maybePendingWrite.bytes!);
+      _stringContentCache[id] = converted;
+      return converted;
+    }
+
     var bytes = _bytesContentCache[id];
     if (bytes == null) {
       bytes = ifAbsent();
@@ -129,4 +236,40 @@ class InMemoryFilesystemCache implements FilesystemCache {
     _stringContentCache[id] = result;
     return result;
   }
+
+  @override
+  void writeAsString(
+    AssetId id,
+    String contents, {
+    Encoding encoding = utf8,
+    required void Function() writer,
+  }) {
+    _stringContentCache[id] = contents;
+    _bytesContentCache.remove(id);
+    _existsCache[id] = true;
+
+    final encoded = encoding.encode(contents);
+    _pendingWrites[id] = _PendingWrite(
+      writer: writer,
+      bytes: encoded is Uint8List ? encoded : Uint8List.fromList(encoded),
+    );
+  }
+
+  @override
+  void delete(AssetId id, {required void Function() deleter}) {
+    _stringContentCache.remove(id);
+    _bytesContentCache.remove(id);
+    _existsCache[id] = false;
+    _pendingWrites[id] = _PendingWrite(writer: deleter);
+  }
+}
+
+/// The data that will be written on flush; used for reads before flush.
+class _PendingWrite {
+  final void Function() writer;
+  final Uint8List? bytes;
+
+  _PendingWrite({required this.writer, this.bytes});
+
+  bool get isDelete => bytes == null;
 }

build/test/state/filesystem_cache_test.dart

@@ -45,6 +45,43 @@ void main() {
         isFalse /* updated value */,
       );
     });
+
+    test('reads from latest writeAsBytes without calling ifAbsent', () async {
+      cache.writeAsBytes(
+        txt1,
+        txt1Bytes,
+        writer: () => throw UnimplementedError(),
+      );
+      expect(
+        cache.exists(txt1, ifAbsent: () => throw UnimplementedError()),
+        true,
+      );
+    });
+
+    test('reads from writeAsString without calling ifAbsent', () async {
+      cache.writeAsString(
+        txt1,
+        txt1String,
+        writer: () => throw UnimplementedError(),
+      );
+      expect(
+        cache.exists(txt1, ifAbsent: () => throw UnimplementedError()),
+        true,
+      );
+    });
+
+    test('reads from delete without calling ifAbsent', () async {
+      cache.writeAsString(
+        txt1,
+        txt1String,
+        writer: () => throw UnimplementedError(),
+      );
+      cache.delete(txt1, deleter: () => throw UnimplementedError());
+      expect(
+        cache.exists(txt1, ifAbsent: () => throw UnimplementedError()),
+        false,
+      );
+    });
   });
 
   group('readAsBytes', () {
@@ -68,6 +105,30 @@ void main() {
         txt2Bytes /* updated value */,
       );
     });
+
+    test('reads from latest writeAsBytes without calling ifAbsent', () async {
+      cache.writeAsBytes(
+        txt1,
+        txt1Bytes,
+        writer: () => throw UnimplementedError(),
+      );
+      expect(
+        cache.readAsBytes(txt1, ifAbsent: () => throw UnimplementedError()),
+        txt1Bytes,
+      );
+    });
+
+    test('reads from writeAsString without calling ifAbsent', () async {
+      cache.writeAsString(
+        txt1,
+        txt1String,
+        writer: () => throw UnimplementedError(),
+      );
+      expect(
+        cache.readAsBytes(txt1, ifAbsent: () => throw UnimplementedError()),
+        txt1Bytes,
+      );
+    });
   });
 
   group('readAsString', () {
@@ -92,4 +153,75 @@ void main() {
       );
     });
   });
+
+  test('reads from latest writeAsBytes without calling ifAbsent', () async {
+    cache.writeAsBytes(
+      txt1,
+      txt1Bytes,
+      writer: () => throw UnimplementedError(),
+    );
+    expect(
+      cache.readAsString(txt1, ifAbsent: () => throw UnimplementedError()),
+      txt1String,
+    );
+  });
+
+  test('reads from writeAsString without calling ifAbsent', () async {
+    cache.writeAsString(
+      txt1,
+      txt1String,
+      writer: () => throw UnimplementedError(),
+    );
+    expect(
+      cache.readAsString(txt1, ifAbsent: () => throw UnimplementedError()),
+      txt1String,
+    );
+  });
+
+  group('writeAsBytes', () {
+    test('writes on flush', () async {
+      var written = false;
+      cache.writeAsBytes(
+        txt1,
+        txt1Bytes,
+        writer: () {
+          written = true;
+        },
+      );
+      expect(written, isFalse);
+      cache.flush();
+      expect(written, isTrue);
+    });
+  });
+
+  group('writeAsString', () {
+    test('writes on flush', () async {
+      var written = false;
+      cache.writeAsString(
+        txt1,
+        txt1String,
+        writer: () {
+          written = true;
+        },
+      );
+      expect(written, isFalse);
+      cache.flush();
+      expect(written, isTrue);
+    });
+  });
+
+  group('delete', () {
+    test('deletes on flush', () async {
+      var deleted = false;
+      cache.delete(
+        txt1,
+        deleter: () {
+          deleted = true;
+        },
+      );
+      expect(deleted, isFalse);
+      cache.flush();
+      expect(deleted, isTrue);
+    });
+  });
 }