Skip duplicate checks on startup. (#4233)

Author: davidmorgan

build_runner/lib/src/bootstrap/bootstrapper.dart

@@ -48,7 +48,7 @@ class Bootstrapper {
       await _writeBuildScript();
 
       // Compile if there was any change.
-      if (!_compiler.checkFreshness().outputIsFresh) {
+      if (!_compiler.checkFreshness(digestsAreFresh: false).outputIsFresh) {
         final result = await _compiler.compile(experiments: experiments);
         if (!result.succeeded) {
           if (result.messages != null) {
@@ -93,15 +93,25 @@ class Bootstrapper {
   }
 
   /// Checks freshness of the entrypoint script compiled to kernel.
-  Future<FreshnessResult> checkKernelFreshness() async {
+  ///
+  /// Set [digestsAreFresh] if digests were very recently updated. Then, they
+  /// will be re-used from disk if possible instead of recomputed.
+  Future<FreshnessResult> checkKernelFreshness({
+    required bool digestsAreFresh,
+  }) async {
     if (!ChildProcess.isRunning) {
       // Any real use or realistic test has a child process; so this is only hit
       // in small tests. Return "fresh" so nothing related to recompiling is
       // triggered.
       return FreshnessResult(outputIsFresh: true);
     }
+    if (digestsAreFresh) {
+      final maybeResult = _compiler.checkFreshness(digestsAreFresh: true);
+      if (maybeResult.outputIsFresh) return maybeResult;
+      // Digest file must be missing, continue to compile.
+    }
     await _writeBuildScript();
-    return _compiler.checkFreshness();
+    return _compiler.checkFreshness(digestsAreFresh: false);
   }
 
   /// Whether [path] is a dependency of the entrypoint script compiled to

build_runner/lib/src/bootstrap/depfile.dart

@@ -29,16 +29,27 @@ class Depfile {
 
   /// Checks whether the inputs mentioned in the depfile are fresh.
   ///
-  /// It is fresh if it has not changed and none of its inputs have changed.
-  FreshnessResult checkFreshness() {
+  /// They are fresh if the output exists, the depfile exists, the digest file
+  /// exists and none of the input files has changed.
+  ///
+  /// Set [digestsAreFresh] if digests were very recently updated. Then, they
+  /// will be re-used from disk if possible instead of recomputed.
+  FreshnessResult checkFreshness({required bool digestsAreFresh}) {
     final outputFile = File(outputPath);
     if (!outputFile.existsSync()) return FreshnessResult(outputIsFresh: false);
     final depsFile = File(depfilePath);
     if (!depsFile.existsSync()) return FreshnessResult(outputIsFresh: false);
     final digestFile = File(digestPath);
     if (!digestFile.existsSync()) return FreshnessResult(outputIsFresh: false);
     final digests = digestFile.readAsStringSync();
-    final expectedDigests = _computeDigest();
+
+    if (digestsAreFresh) {
+      _depfilePaths ??= _readPaths();
+      return FreshnessResult(outputIsFresh: true, digest: digests);
+    }
+
+    _depfilePaths = _readPaths();
+    final expectedDigests = _digestPaths();
     return digests == expectedDigests
         ? FreshnessResult(outputIsFresh: true, digest: digests)
         : FreshnessResult(outputIsFresh: false);
@@ -53,18 +64,18 @@ class Depfile {
   /// Writes a digest of all input files mentioned in [depfilePath] to
   /// [digestPath].
   void writeDigest() {
-    File(digestPath).writeAsStringSync(_computeDigest());
+    _depfilePaths = _readPaths();
+    File(digestPath).writeAsStringSync(_digestPaths());
   }
 
-  String _computeDigest() {
+  /// Reads input paths from the depfile.
+  Set<String> _readPaths() {
     final depsFile = File(depfilePath).readAsStringSync();
-    final paths = parse(depsFile);
-    _depfilePaths = paths.toSet();
-    return _digestPaths(paths);
+    return parse(depsFile);
   }
 
   @visibleForTesting
-  static List<String> parse(String deps) {
+  static Set<String> parse(String deps) {
     // The depfile has the output path followed by a colon then a
     // space-separated list of input paths. Backslashes and spaces in paths are
     // backslash escaped.
@@ -75,19 +86,25 @@ class Depfile {
         .replaceAll(r'\ ', '\u0000')
         // And unescape backslashes.
         .replaceAll(r'\\', r'\')
-        .split(' ')
-        .map((item) => item.replaceAll('\u0000', ' '));
-
-    final result = items.skip(1).toList();
-    // File ends in a newline.
-    result.last = result.last.substring(0, result.last.length - 1);
+        .split(' ');
+
+    final result = <String>{};
+    // The first item is the output path, skip it.
+    for (var i = 1; i != items.length; ++i) {
+      final item = items[i];
+      final path = item.replaceAll('\u0000', ' ');
+      // File ends in a newline.
+      result.add(
+        i == items.length - 1 ? path.substring(0, path.length - 1) : path,
+      );
+    }
     return result;
   }
 
-  String _digestPaths(Iterable<String> deps) {
+  String _digestPaths() {
     final digestSink = AccumulatorSink<Digest>();
     final result = md5.startChunkedConversion(digestSink);
-    for (final dep in deps) {
+    for (final dep in _depfilePaths!) {
       final file = File(dep);
       if (file.existsSync()) {
         result.add([1]);

build_runner/lib/src/bootstrap/kernel_compiler.dart

@@ -21,7 +21,11 @@ class KernelCompiler {
   );
 
   /// Checks freshness of the build script compiled kernel.
-  FreshnessResult checkFreshness() => _outputDepfile.checkFreshness();
+  ///
+  /// Set [digestsAreFresh] if digests were very recently updated. Then, they
+  /// will be re-used from disk if possible instead of recomputed.
+  FreshnessResult checkFreshness({required bool digestsAreFresh}) =>
+      _outputDepfile.checkFreshness(digestsAreFresh: digestsAreFresh);
 
   /// Checks whether [path] in a dependency of the build script compiled kernel.
   ///

build_runner/lib/src/build/build_series.dart

@@ -206,22 +206,32 @@ class BuildSeries {
   ///
   /// For further builds, pass the changes since the previous builds as
   /// [updates].
+  ///
+  /// Set [recentlyBootstrapped] to skip doing checks that are done during
+  /// bootstrapping. If [recentlyBootstrapped] then [updates] must be empty.
   Future<BuildResult> run(
     Map<AssetId, ChangeType> updates, {
+    required bool recentlyBootstrapped,
     BuiltSet<BuildDirectory>? buildDirs,
     BuiltSet<BuildFilter>? buildFilters,
   }) async {
     if (_closingCompleter.isCompleted) {
       throw StateError('BuildSeries was closed.');
     }
 
-    final kernelFreshness =
-        await _buildPlan.bootstrapper.checkKernelFreshness();
-    if (!kernelFreshness.outputIsFresh) {
-      final result = BuildResult.buildScriptChanged();
-      _buildResultsController.add(result);
-      await close();
-      return result;
+    if (recentlyBootstrapped) {
+      if (updates.isNotEmpty) {
+        throw StateError('`recentlyBootstrapped` but updates not empty.');
+      }
+    } else {
+      final kernelFreshness = await _buildPlan.bootstrapper
+          .checkKernelFreshness(digestsAreFresh: false);
+      if (!kernelFreshness.outputIsFresh) {
+        final result = BuildResult.buildScriptChanged();
+        _buildResultsController.add(result);
+        await close();
+        return result;
+      }
     }
 
     if (updates.keys.any(_isBuildConfiguration)) {

build_runner/lib/src/build_plan/build_plan.dart

@@ -96,14 +96,20 @@ class BuildPlan {
   /// Files that should be deleted before restarting or building are accumulated
   /// in [filesToDelete] and [foldersToDelete]. Call [deleteFilesAndFolders] to
   /// delete them.
+  ///
+  /// Set [recentlyBootstrapped] to false to do checks that are also done during
+  /// bootstrapping.
   static Future<BuildPlan> load({
     required BuilderFactories builderFactories,
     required BuildOptions buildOptions,
     required TestingOverrides testingOverrides,
+    bool recentlyBootstrapped = true,
   }) async {
     final bootstrapper = Bootstrapper();
     var restartIsNeeded = false;
-    final kernelFreshness = await bootstrapper.checkKernelFreshness();
+    final kernelFreshness = await bootstrapper.checkKernelFreshness(
+      digestsAreFresh: recentlyBootstrapped,
+    );
     if (!kernelFreshness.outputIsFresh) {
       restartIsNeeded = true;
     }
@@ -350,15 +356,16 @@ class BuildPlan {
 
   /// Reloads the build plan.
   ///
-  /// Works just like a new load of the build plan, but supresses the usual log
-  /// output.
+  /// Works just like a new load of the build plan, but sets
+  /// `recentlyBootstrapped` to `false` to redo checks from bootstrapping.
   ///
   /// The caller must call [deleteFilesAndFolders] on the result and check
   /// [restartIsNeeded].
   Future<BuildPlan> reload() => BuildPlan.load(
     builderFactories: builderFactories,
     buildOptions: buildOptions,
     testingOverrides: testingOverrides,
+    recentlyBootstrapped: false,
   );
 }
 

build_runner/lib/src/commands/build_command.dart

@@ -57,7 +57,7 @@ class BuildCommand implements BuildRunnerCommand {
     }
 
     final buildSeries = BuildSeries(buildPlan);
-    final result = await buildSeries.run({});
+    final result = await buildSeries.run({}, recentlyBootstrapped: true);
     await buildSeries.close();
     return result;
   }

build_runner/lib/src/commands/daemon/daemon_builder.dart

@@ -110,6 +110,7 @@ class BuildRunnerDaemonBuilder implements DaemonBuilder {
       final mergedChanges = collectChanges([changes]);
       final result = await buildSeries.run(
         mergedChanges,
+        recentlyBootstrapped: false,
         buildDirs: buildDirs.build(),
         buildFilters: buildFilters.build(),
       );

build_runner/lib/src/commands/watch/watcher.dart

@@ -78,13 +78,16 @@ class Watcher {
         .ignore();
 
     await graphWatcher.ready;
-    await _buildSeries.run({});
+    await _buildSeries.run({}, recentlyBootstrapped: true);
   }
 
   Future<BuildResult> _doBuild(List<List<AssetChange>> changes) async {
     final mergedChanges = collectChanges(changes);
     _expectedDeletes.clear();
-    final result = await _buildSeries.run(mergedChanges);
+    final result = await _buildSeries.run(
+      mergedChanges,
+      recentlyBootstrapped: false,
+    );
     return result;
   }
 }

build_runner/test/common/test_phases.dart

@@ -154,7 +154,7 @@ Future<TestBuildersResult> testPhases(
 
   BuildResult result;
   final buildSeries = BuildSeries(buildPlan);
-  result = await buildSeries.run({});
+  result = await buildSeries.run({}, recentlyBootstrapped: true);
   await buildSeries.close();
 
   if (checkBuildStatus) {

build_runner/test/integration_tests/kernel_compiler_test.dart

@@ -27,7 +27,7 @@ import 'dart:io';
 import 'package:build_runner/src/bootstrap/kernel_compiler.dart';
 void main() async {
   final compiler = KernelCompiler();
-  if (compiler.checkFreshness().outputIsFresh) {
+  if (compiler.checkFreshness(digestsAreFresh: false).outputIsFresh) {
     stdout.write('fresh\n');
   } else {
     stdout.write('compiling\n');