Add Filesystem underneath Reader, simplify tests further.

Author: davidmorgan

_test_common/lib/in_memory_reader_writer.dart

@@ -16,7 +16,7 @@ class InMemoryRunnerAssetReaderWriter extends InMemoryAssetReaderWriter
   Stream<AssetId> get onCanRead => _onCanReadController.stream;
   void Function(AssetId)? onDelete;
 
-  InMemoryRunnerAssetReaderWriter({super.sourceAssets, super.rootPackage});
+  InMemoryRunnerAssetReaderWriter({super.rootPackage});
 
   @override
   Future<bool> canRead(AssetId id) {

build/lib/src/builder/build_step_impl.dart

@@ -20,6 +20,7 @@ import '../asset/writer.dart';
 import '../resource/resource.dart';
 import '../state/asset_finder.dart';
 import '../state/asset_path_provider.dart';
+import '../state/filesystem.dart';
 import '../state/input_tracker.dart';
 import '../state/reader_state.dart';
 import 'build_step.dart';
@@ -82,6 +83,9 @@ class BuildStepImpl implements BuildStep, AssetReaderState {
         _stageTracker = stageTracker ?? NoOpStageTracker.instance,
         _reportUnusedAssets = reportUnusedAssets;
 
+  @override
+  Filesystem get filesystem => _reader.filesystem;
+
   @override
   AssetFinder get assetFinder => _reader.assetFinder;
 

build/lib/src/internal.dart

@@ -8,5 +8,6 @@ library;
 
 export 'state/asset_finder.dart';
 export 'state/asset_path_provider.dart';
+export 'state/filesystem.dart';
 export 'state/input_tracker.dart';
 export 'state/reader_state.dart';

build/lib/src/state/filesystem.dart

@@ -0,0 +1,27 @@
+// 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:convert';
+import 'dart:typed_data';
+
+import '../asset/id.dart';
+
+/// The filesystem the build is running on.
+abstract interface class Filesystem {
+  Future<bool> exists(AssetId id);
+
+  Future<String> readAsString(AssetId id, {Encoding encoding = utf8});
+  Future<Uint8List> readAsBytes(AssetId id);
+
+  Future<void> delete(AssetId id);
+  void deleteSync(AssetId id);
+
+  void writeAsStringSync(AssetId id, String contents,
+      {Encoding encoding = utf8});
+  Future<void> writeAsString(AssetId id, String contents,
+      {Encoding encoding = utf8});
+
+  void writeAsBytesSync(AssetId id, List<int> contents);
+  Future<void> writeAsBytes(AssetId id, List<int> contents);
+}

build/lib/src/state/reader_state.dart

@@ -5,10 +5,16 @@
 import '../asset/reader.dart';
 import 'asset_finder.dart';
 import 'asset_path_provider.dart';
+import 'filesystem.dart';
 import 'input_tracker.dart';
 
 /// Provides access to the state backing an [AssetReader].
 extension AssetReaderStateExtension on AssetReader {
+  Filesystem get filesystem {
+    _requireIsAssetReaderState();
+    return (this as AssetReaderState).filesystem;
+  }
+
   AssetFinder get assetFinder {
     _requireIsAssetReaderState();
     return (this as AssetReaderState).assetFinder;
@@ -43,6 +49,12 @@ extension AssetReaderStateExtension on AssetReader {
 
 /// The state backing an [AssetReader].
 abstract interface class AssetReaderState {
+  /// The [Filesystem] that this reader reads from.
+  ///
+  /// Warning: this access to the filesystem bypasses reader functionality
+  /// such as read tracking, caching and visibility restriction.
+  Filesystem get filesystem;
+
   /// The [AssetFinder] associated with this reader.
   ///
   /// All readers have an [AssetFinder], but the functionality it provides,

build/test/generate/run_post_process_builder_test.dart

@@ -11,8 +11,7 @@ import '../common/builders.dart';
 
 void main() {
   group('runPostProcessBuilder', () {
-    late InMemoryAssetReader reader;
-    late InMemoryAssetWriter writer;
+    late InMemoryAssetReaderWriter readerWriter;
     final copyBuilder = CopyingPostProcessBuilder();
     final deleteBuilder = DeletePostProcessBuilder();
     final aTxt = makeAssetId('a|lib/a.txt');
@@ -24,38 +23,37 @@ void main() {
     void addAsset(AssetId id) => adds[id] = true;
     void deleteAsset(AssetId id) => deletes[id] = true;
 
-    Map<AssetId, String> sourceAssets;
-
     setUp(() async {
-      sourceAssets = {
-        aTxt: 'a',
-      };
-      reader = InMemoryAssetReader(sourceAssets: sourceAssets);
-      writer = InMemoryAssetWriter();
+      readerWriter = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(aTxt, 'a');
       adds.clear();
       deletes.clear();
     });
 
     test('can delete assets', () async {
-      await runPostProcessBuilder(copyBuilder, aTxt, reader, writer, logger,
+      await runPostProcessBuilder(
+          copyBuilder, aTxt, readerWriter, readerWriter, logger,
           addAsset: addAsset, deleteAsset: deleteAsset);
-      await runPostProcessBuilder(deleteBuilder, aTxt, reader, writer, logger,
+      await runPostProcessBuilder(
+          deleteBuilder, aTxt, readerWriter, readerWriter, logger,
           addAsset: addAsset, deleteAsset: deleteAsset);
       expect(deletes, contains(aTxt));
       expect(deletes, isNot(contains(aTxtCopy)));
     });
 
     test('can create assets and read the primary asset', () async {
-      await runPostProcessBuilder(copyBuilder, aTxt, reader, writer, logger,
+      await runPostProcessBuilder(
+          copyBuilder, aTxt, readerWriter, readerWriter, logger,
           addAsset: addAsset, deleteAsset: deleteAsset);
-      expect(writer.assets, contains(aTxtCopy));
-      expect(writer.assets[aTxtCopy], decodedMatches('a'));
+      expect(readerWriter.assets, contains(aTxtCopy));
+      expect(readerWriter.assets[aTxtCopy], decodedMatches('a'));
       expect(adds, contains(aTxtCopy));
     });
 
     test('throws if addAsset throws', () async {
       expect(
-          () => runPostProcessBuilder(copyBuilder, aTxt, reader, writer, logger,
+          () => runPostProcessBuilder(
+              copyBuilder, aTxt, readerWriter, readerWriter, logger,
               addAsset: (id) => throw InvalidOutputException(id, ''),
               deleteAsset: deleteAsset),
           throwsA(const TypeMatcher<InvalidOutputException>()));

build_modules/test/decoding_cache_test.dart

@@ -39,53 +39,64 @@ void main() {
 
     test('can fetch from disk', () async {
       final id = AssetId('foo', 'lib/foo');
-      final reader = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       expect(await cache.find(id, reader), 'foo');
-      expect(reader.assetsRead, contains(id));
+      expect(reader.inputTracker.assetsRead, contains(id));
       expect(fromBytesCalls, contains('foo'));
     });
 
     test('skips read for value written this build', () async {
       final id = AssetId('foo', 'lib/foo');
-      final reader = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       await cache.write(id, InMemoryAssetWriter(), 'bar');
       expect(await cache.find(id, reader), 'bar');
-      expect(reader.assetsRead, contains(id), reason: 'Should call canRead');
+      expect(reader.inputTracker.assetsRead, contains(id),
+          reason: 'Should call canRead');
       expect(fromBytesCalls, isNot(contains('bar')));
     });
 
     test('skips read on subsequent fetches', () async {
       final id = AssetId('foo', 'lib/foo');
-      final reader1 = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader1 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       await cache.find(id, reader1);
       expect(fromBytesCalls['foo'], 1);
-      final reader2 = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader2 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       expect(await cache.find(id, reader2), 'foo');
-      expect(reader2.assetsRead, contains(id), reason: 'Should call canRead');
+      expect(reader2.inputTracker.assetsRead, contains(id),
+          reason: 'Should call canRead');
       expect(fromBytesCalls['foo'], 1, reason: 'No extra call to deserialize');
     });
 
     test('skips read on subsequent builds if digest has not changed', () async {
       final id = AssetId('foo', 'lib/foo');
-      final reader1 = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader1 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       await cache.find(id, reader1);
       expect(fromBytesCalls['foo'], 1);
       await resourceManager.disposeAll();
-      final reader2 = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader2 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       expect(await cache.find(id, reader2), 'foo');
-      expect(reader2.assetsRead, contains(id), reason: 'Should call canRead');
+      expect(reader2.inputTracker.assetsRead, contains(id),
+          reason: 'Should call canRead');
       expect(fromBytesCalls['foo'], 1, reason: 'No extra call to deserialize');
     });
 
     test('rereads on subsequent builds if digest has changed', () async {
       final id = AssetId('foo', 'lib/foo');
-      final reader1 = InMemoryAssetReader(sourceAssets: {id: 'foo'});
+      final reader1 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'foo');
       await cache.find(id, reader1);
       expect(fromBytesCalls['foo'], 1);
       await resourceManager.disposeAll();
-      final reader2 = InMemoryAssetReader(sourceAssets: {id: 'bar'});
+      final reader2 = InMemoryAssetReaderWriter()
+        ..filesystem.writeAsStringSync(id, 'bar');
       expect(await cache.find(id, reader2), 'bar');
-      expect(reader2.assetsRead, contains(id));
+      expect(reader2.inputTracker.assetsRead, contains(id));
       expect(fromBytesCalls['bar'], 1, reason: 'Deserialize with new value');
     });
   });

build_resolvers/test/resolver_test.dart

@@ -138,7 +138,7 @@ void runTests(ResolversFactory resolversFactory) {
     }, (resolver) async {
       await resolver.libraryFor(entryPoint);
     }, assetReaderChecks: (reader) {
-      expect(reader.assetsRead, {
+      expect(reader.inputTracker!.assetsRead, {
         AssetId('a', 'web/main.dart'),
         AssetId('a', 'web/main.dart.transitive_digest'),
         AssetId('a', 'web/a.dart'),
@@ -181,7 +181,7 @@ void runTests(ResolversFactory resolversFactory) {
     await resolveSources(sources, (resolver) async {
       await resolver.libraryFor(entryPoint);
     }, assetReaderChecks: (reader) {
-      expect(reader.assetsRead, {
+      expect(reader.inputTracker!.assetsRead, {
         AssetId('a', 'web/main.dart'),
         AssetId('a', 'web/main.dart.transitive_digest'),
         AssetId('a', 'web/a.dart'),
@@ -194,7 +194,7 @@ void runTests(ResolversFactory resolversFactory) {
     await resolveSources(sources, (resolver) async {
       await resolver.libraryFor(entryPoint);
     }, assetReaderChecks: (reader) {
-      expect(reader.assetsRead, {
+      expect(reader.inputTracker!.assetsRead, {
         AssetId('a', 'web/main.dart'),
         AssetId('a', 'web/main.dart.transitive_digest'),
         AssetId('a', 'web/a.dart'),

build_runner/test/generate/watch_test.dart

@@ -14,7 +14,6 @@ import 'package:build_runner/src/generate/watch_impl.dart' as watch_impl;
 import 'package:build_runner_core/build_runner_core.dart';
 import 'package:build_runner_core/src/asset_graph/graph.dart';
 import 'package:build_runner_core/src/asset_graph/node.dart';
-import 'package:build_test/build_test.dart';
 import 'package:logging/logging.dart';
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
@@ -284,7 +283,7 @@ void main() {
             <AssetId>{},
             {packageConfigId},
             buildPackageGraph({rootPackage('a'): []}),
-            InMemoryAssetReader(sourceAssets: readerWriter.assets));
+            readerWriter);
 
         var builderOptionsId = makeAssetId('a|Phase0.builderOptions');
         var builderOptionsNode = BuilderOptionsAssetNode(builderOptionsId,

build_runner_core/lib/src/asset/batch.dart

@@ -81,6 +81,9 @@ final class BatchReader extends AssetReader implements AssetReaderState {
 
   BatchReader(this._inner, this._batch);
 
+  @override
+  Filesystem get filesystem => _inner.filesystem;
+
   @override
   AssetPathProvider? get assetPathProvider => _inner.assetPathProvider;
 

build_runner_core/lib/src/asset/build_cache.dart

@@ -33,6 +33,9 @@ class BuildCacheReader implements AssetReader, AssetReaderState {
                 delegate: delegate.assetPathProvider!,
                 overlay: (id) => _cacheLocation(id, assetGraph, rootPackage));
 
+  @override
+  Filesystem get filesystem => _delegate.filesystem;
+
   @override
   AssetFinder get assetFinder => _delegate.assetFinder;
 

build_runner_core/lib/src/asset/cache.dart

@@ -47,6 +47,9 @@ class CachingAssetReader implements AssetReader, AssetReaderState {
 
   CachingAssetReader(this._delegate);
 
+  @override
+  Filesystem get filesystem => _delegate.filesystem;
+
   @override
   AssetPathProvider? get assetPathProvider => _delegate.assetPathProvider;