Add to resolver_test, add to AnalysisDriverModel as needed to satisfy the tests.

Run the tests with both "shared" instances, re-used between tests (as before) and "new" instances.

Author: davidmorgan

build_resolvers/lib/src/analysis_driver_model.dart

@@ -15,6 +15,8 @@ import 'package:path/path.dart' as p;
 
 import 'analysis_driver_model_uri_resolver.dart';
 
+const _transitiveDigestExtension = '.transitive_digest';
+
 /// Manages analysis driver and related build state.
 ///
 /// - Tracks the import graph of all sources needed for analysis.
@@ -34,16 +36,18 @@ class AnalysisDriverModel {
   final MemoryResourceProvider resourceProvider =
       MemoryResourceProvider(context: p.posix);
 
+  final _graph = _Graph();
+  final _readForAnalyzer = <AssetId>{};
+
   /// Notifies that [step] has completed.
   ///
   /// All build steps must complete before [reset] is called.
-  void notifyComplete(BuildStep step) {
-    // TODO(davidmorgan): add test coverage, fix implementation.
-  }
+  void notifyComplete(BuildStep step) {}
 
   /// Clear cached information specific to an individual build.
   void reset() {
-    // TODO(davidmorgan): add test coverage, fix implementation.
+    _graph.clear();
+    _readForAnalyzer.clear();
   }
 
   /// Attempts to parse [uri] into an [AssetId] and returns it if it is cached.
@@ -82,66 +86,70 @@ class AnalysisDriverModel {
               FutureOr<void> Function(AnalysisDriverForPackageBuild))
           withDriverResource,
       {required bool transitive}) async {
-    /// TODO(davidmorgan): add test coverage for whether transitive
-    /// sources are read when [transitive] is false, fix the implementation
-    /// here.
-    /// TODO(davidmorgan): add test coverage for whether
-    /// `.transitive_deps` files cut off the reporting of deps to the
-    /// [buildStep], fix the implementation here.
-
-    // Find transitive deps, this also informs [buildStep] of all inputs).
-    final ids = await _expandToTransitive(buildStep, entryPoints);
-
-    // Apply changes to in-memory filesystem.
-    for (final id in ids) {
-      if (await buildStep.canRead(id)) {
-        final content = await buildStep.readAsString(id);
-
-        /// TODO(davidmorgan): add test coverage for when a file is
-        /// modified rather than added, fix the implementation here.
-        resourceProvider.newFile(id.asPath, content);
-      } else {
-        if (resourceProvider.getFile(id.asPath).exists) {
-          resourceProvider.deleteFile(id.asPath);
+    await withDriverResource((driver) async {
+      var analyzerIds = entryPoints;
+      Iterable<AssetId> inputIds = entryPoints;
+
+      // If requested, find transitive imports.
+      if (transitive) {
+        await _graph.load(buildStep, entryPoints);
+        // TODO(davidmorgan): use just the set for the entrypoints.
+        analyzerIds = _graph.nodes.keys.toList();
+        inputIds = _graph.inputsFor(entryPoints);
+
+        // Check for missing inputs that were written during the build.
+        for (final id in inputIds
+            .where((id) => !id.path.endsWith(_transitiveDigestExtension))) {
+          if (_graph.nodes[id]!.isMissing) {
+            if (await buildStep.canRead(id)) {
+              analyzerIds.add(id);
+              _readForAnalyzer.remove(id);
+            }
+          }
         }
       }
-    }
 
-    // Notify the analyzer of changes.
-    await withDriverResource((driver) async {
-      for (final id in ids) {
-        // TODO(davidmorgan): add test coverage for over-notification of
-        // changes, fix the implementaion here.
-        driver.changeFile(id.asPath);
+      // Notify [buildStep] of its inputs.
+      for (final id in inputIds) {
+        await buildStep.canRead(id);
       }
-      await driver.applyPendingFileChanges();
-    });
-  }
 
-  /// Walks the import graph from [ids], returns full transitive deps.
-  Future<Set<AssetId>> _expandToTransitive(
-      AssetReader reader, Iterable<AssetId> ids) async {
-    final result = ids.toSet();
-    final nextIds = Queue.of(ids);
-    while (nextIds.isNotEmpty) {
-      final nextId = nextIds.removeFirst();
-
-      // Skip if not readable. Note that calling `canRead` still makes it a
-      // dependency of the `BuildStep`.
-      if (!await reader.canRead(nextId)) continue;
-
-      final content = await reader.readAsString(nextId);
-      final deps = _parseDependencies(content, nextId);
+      // Apply changes to in-memory filesystem.
+      final changedIds = <AssetId>[];
+      for (final id in analyzerIds) {
+        if (!_readForAnalyzer.add(id)) continue;
+        final content = await buildStep.canRead(id)
+            ? await buildStep.readAsString(id)
+            : null;
+        final inMemoryFile = resourceProvider.getFile(id.asPath);
+        final inMemoryContent =
+            inMemoryFile.exists ? inMemoryFile.readAsStringSync() : null;
 
-      // For each dep, if it's not in `result` yet, it's newly-discovered:
-      // add it to `nextIds`.
-      for (final dep in deps) {
-        if (result.add(dep)) {
-          nextIds.add(dep);
+        if (content != inMemoryContent) {
+          if (content == null) {
+            // TODO(davidmorgan): per "globallySeenAssets" in
+            // BuildAssetUriResolver, deletes should only be applied at the end
+            // of the build, in case the file is actually there but not visible
+            // to the current reader.
+            resourceProvider.deleteFile(id.asPath);
+            changedIds.add(id);
+          } else {
+            if (inMemoryContent == null) {
+              resourceProvider.newFile(id.asPath, content);
+            } else {
+              resourceProvider.modifyFile(id.asPath, content);
+            }
+            changedIds.add(id);
+          }
         }
       }
-    }
-    return result;
+
+      // Notify the analyzer of changes.
+      for (final id in changedIds) {
+        driver.changeFile(id.asPath);
+      }
+      await driver.applyPendingFileChanges();
+    });
   }
 }
 
@@ -167,3 +175,95 @@ extension _AssetIdExtensions on AssetId {
   /// Asset path for the in-memory filesystem.
   String get asPath => AnalysisDriverModelUriResolver.assetPath(this);
 }
+
+class _Graph {
+  final Map<AssetId, _Node> nodes = {};
+
+  /// Walks the import graph from [ids] loading into [nodes].
+  Future<void> load(AssetReader reader, Iterable<AssetId> ids) async {
+    final nextIds = Queue.of(ids);
+    while (nextIds.isNotEmpty) {
+      final nextId = nextIds.removeFirst();
+
+      // Skip if already seen.
+      if (nodes.containsKey(nextId)) continue;
+
+      final hasTransitiveDigestAsset =
+          await reader.canRead(nextId.addExtension(_transitiveDigestExtension));
+
+      // Skip if not readable.
+      if (!await reader.canRead(nextId)) {
+        nodes[nextId] = _Node(
+            id: nextId,
+            deps: null,
+            hasTransitiveDigestAsset: hasTransitiveDigestAsset);
+        continue;
+      }
+
+      final content = await reader.readAsString(nextId);
+      final deps = _parseDependencies(content, nextId);
+      nodes[nextId] = _Node(
+          id: nextId,
+          deps: deps,
+          hasTransitiveDigestAsset: hasTransitiveDigestAsset);
+      nextIds.addAll(deps.where((id) => !nodes.containsKey(id)));
+    }
+  }
+
+  void clear() {
+    nodes.clear();
+  }
+
+  /// The inputs for a build action analyzing [entryPoints].
+  ///
+  /// This is transitive deps, but cut off by the presence of any
+  /// `.transitive_digest` file next to an asset.
+  Set<AssetId> inputsFor(Iterable<AssetId> entryPoints) {
+    final result = entryPoints.toSet();
+    final nextIds = Queue.of(entryPoints);
+
+    while (nextIds.isNotEmpty) {
+      final nextId = nextIds.removeFirst();
+      final node = nodes[nextId]!;
+
+      // Add the transitive digest file as an input. If it exists, skip deps.
+      result.add(nextId.addExtension(_transitiveDigestExtension));
+      if (node.hasTransitiveDigestAsset) {
+        continue;
+      }
+
+      // Skip if there are no deps because the file is missing.
+      if (node.deps == null) continue;
+
+      // For each dep, if it's not in `result` yet, it's newly-discovered:
+      // add it to `nextIds`.
+      for (final dep in node.deps!) {
+        if (result.add(dep)) {
+          nextIds.add(dep);
+        }
+      }
+    }
+    return result;
+  }
+
+  @override
+  String toString() => nodes.toString();
+}
+
+class _Node {
+  final AssetId id;
+  final List<AssetId>? deps;
+  final bool hasTransitiveDigestAsset;
+
+  _Node(
+      {required this.id,
+      required this.deps,
+      required this.hasTransitiveDigestAsset});
+
+  bool get isMissing => deps == null;
+
+  @override
+  String toString() => '$id:'
+      '${hasTransitiveDigestAsset ? 'digest:' : ''}'
+      '${deps?.toString() ?? 'missing'}';
+}