Enforce single computeDelta() invocation.

pkg/front_end/lib/src/incremental_kernel_generator_impl.dart

 // Copyright (c) 2017, 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:async';
 
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
@@ skipping 18 matching lines @@
 
   /// The URI of the program entry point.
   final Uri _entryPoint;
 
   /// The function to notify when files become used or unused, or `null`.
   final WatchUsedFilesFn _watchFn;
 
   /// The [KernelDriver] that is used to compute kernels.
   KernelDriver _driver;
 
+  /// Whether [computeDelta] is executing.
+  bool _isComputeDeltaExecuting = false;
+
   /// The current signatures for libraries.
   final Map<Uri, String> _currentSignatures = {};
 
   /// The signatures for libraries produced by the last [computeDelta], or
   /// `null` if the last delta was either accepted or rejected.
   Map<Uri, String> _lastSignatures;
 
   /// The object that provides additional information for tests.
   _TestView _testView;
 
@@ skipping 21 matching lines @@
 
   @override
   void acceptLastDelta() {
     _throwIfNoLastDelta();
     _currentSignatures.addAll(_lastSignatures);
     _lastSignatures = null;
   }
 
   @override
   Future<DeltaProgram> computeDelta() async {
-    if (_lastSignatures != null) {
+    if (_isComputeDeltaExecuting) {
       throw new StateError(
-          'The last delta must be either accepted or rejected.');
+          'Another computeDelta() invocation is still executing.');
     }
-    _lastSignatures = {};
+    _isComputeDeltaExecuting = true;
 
-    return await _logger.runAsync('Compute delta', () async {
-      KernelResult kernelResult = await _driver.getKernel(_entryPoint);
-      List<LibraryCycleResult> results = kernelResult.results;
+    try {
+      if (_lastSignatures != null) {
+        throw new StateError(
+            'The last delta must be either accepted or rejected.');
+      }
+      _lastSignatures = {};
 
-      // The file graph might have changed, perform GC.
-      await _gc();
+      return await _logger.runAsync('Compute delta', () async {
+        KernelResult kernelResult = await _driver.getKernel(_entryPoint);
+        List<LibraryCycleResult> results = kernelResult.results;
 
-      // The set of affected library cycles (have different signatures).
-      final affectedLibraryCycles = new Set<LibraryCycle>();
-      for (LibraryCycleResult result in results) {
-        for (Library library in result.kernelLibraries) {
-          Uri uri = library.importUri;
-          if (_currentSignatures[uri] != result.signature) {
-            _lastSignatures[uri] = result.signature;
-            affectedLibraryCycles.add(result.cycle);
+        // The file graph might have changed, perform GC.
+        await _gc();
+
+        // The set of affected library cycles (have different signatures).
+        final affectedLibraryCycles = new Set<LibraryCycle>();
+        for (LibraryCycleResult result in results) {
+          for (Library library in result.kernelLibraries) {
+            Uri uri = library.importUri;
+            if (_currentSignatures[uri] != result.signature) {
+              _lastSignatures[uri] = result.signature;
+              affectedLibraryCycles.add(result.cycle);
+            }
           }
         }
-      }
 
-      // The set of affected library cycles (have different signatures),
-      // or libraries that import or export affected libraries (so VM might
-      // have inlined some code from affected libraries into them).
-      final vmRequiredLibraryCycles = new Set<LibraryCycle>();
+        // The set of affected library cycles (have different signatures),
+        // or libraries that import or export affected libraries (so VM might
+        // have inlined some code from affected libraries into them).
+        final vmRequiredLibraryCycles = new Set<LibraryCycle>();
 
-      void gatherVmRequiredLibraryCycles(LibraryCycle cycle) {
-        if (vmRequiredLibraryCycles.add(cycle)) {
-          cycle.directUsers.forEach(gatherVmRequiredLibraryCycles);
-        }
-      }
-
-      affectedLibraryCycles.forEach(gatherVmRequiredLibraryCycles);
-
-      // Add required libraries.
-      Program program = new Program(nameRoot: kernelResult.nameRoot);
-      for (LibraryCycleResult result in results) {
-        if (vmRequiredLibraryCycles.contains(result.cycle)) {
-          for (Library library in result.kernelLibraries) {
-            program.libraries.add(library);
-            library.parent = program;
+        void gatherVmRequiredLibraryCycles(LibraryCycle cycle) {
+          if (vmRequiredLibraryCycles.add(cycle)) {
+            cycle.directUsers.forEach(gatherVmRequiredLibraryCycles);
           }
         }
-      }
 
-      // Set the main method.
-      if (program.libraries.isNotEmpty) {
-        for (Library library in results.last.kernelLibraries) {
-          if (library.importUri == _entryPoint) {
-            program.mainMethod = library.procedures.firstWhere(
-                (procedure) => procedure.name.name == 'main',
-                orElse: () => null);
-            break;
+        affectedLibraryCycles.forEach(gatherVmRequiredLibraryCycles);
+
+        // Add required libraries.
+        Program program = new Program(nameRoot: kernelResult.nameRoot);
+        for (LibraryCycleResult result in results) {
+          if (vmRequiredLibraryCycles.contains(result.cycle)) {
+            for (Library library in result.kernelLibraries) {
+              program.libraries.add(library);
+              library.parent = program;
+            }
           }
         }
-      }
 
-      return new DeltaProgram(program);
-    });
+        // Set the main method.
+        if (program.libraries.isNotEmpty) {
+          for (Library library in results.last.kernelLibraries) {
+            if (library.importUri == _entryPoint) {
+              program.mainMethod = library.procedures.firstWhere(
+                  (procedure) => procedure.name.name == 'main',
+                  orElse: () => null);
+              break;
+            }
+          }
+        }
+
+        return new DeltaProgram(program);
+      });
+    } finally {
+      _isComputeDeltaExecuting = false;
+    }
   }
 
   @override
   void invalidate(Uri uri) {
     _driver.invalidate(uri);
   }
 
   @override
   void rejectLastDelta() {
     _throwIfNoLastDelta();
     _lastSignatures = null;
   }
 
-  /// TODO(scheglov) document
+  /// Find files which are not referenced from the entry point and report
+  /// them to the watch function.
   Future<Null> _gc() async {
     var removedFiles = _driver.fsState.gc(_entryPoint);
     if (removedFiles.isNotEmpty && _watchFn != null) {
       for (var removedFile in removedFiles) {
         await _watchFn(removedFile.fileUri, false);
       }
     }
   }
 
   /// Throw [StateError] if [_lastSignatures] is `null`, i.e. there is no
   /// last delta - it either has not been computed yet, or has been already
   /// accepted or rejected.
   void _throwIfNoLastDelta() {
     if (_lastSignatures == null) {

[Siggi Cherem (dart-lang), 2017/08/10 22:43:29]

could we also check here that _isComputeDeltaExecuting is false?

this was my main concern before: if its true, we might clear _lastSignature and
potentially produce a failure in computeDelta when trying to update
_lastSignatures in line 109

[scheglov, 2017/08/10 23:46:49]

Done.

       throw new StateError(
           'The last delta has been already accepted or rejected.');
     }
   }
 }
 
 @visibleForTesting
 class _TestView {
   final IncrementalKernelGeneratorImpl _generator;
 
   _TestView(this._generator);
 
   /// The [KernelDriver] that is used to actually compile.
   KernelDriver get driver => _generator._driver;
 }