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';
 import 'package:front_end/src/incremental/file_state.dart';
 import 'package:front_end/src/incremental/kernel_driver.dart';
 import 'package:kernel/kernel.dart' hide Source;
 import 'package:meta/meta.dart';
 
 /// Implementation of [IncrementalKernelGenerator].
 ///
 /// TODO(scheglov) Update the documentation.
 ///
 /// Theory of operation: an instance of [IncrementalResolvedAstGenerator] is
 /// used to obtain resolved ASTs, and these are fed into kernel code generation
 /// logic.
 class IncrementalKernelGeneratorImpl implements IncrementalKernelGenerator {
-  /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 1;
+  static const MSG_PENDING_COMPUTE =

[Siggi Cherem (dart-lang), 2017/08/11 00:44:52]

not for this CL: even if we don't report them on the regular API, it might be
worth using messages.yaml as well. You can still extract the message and throw
it :) Or use `internalProblem` like we do in other parts of the compiler.

[scheglov, 2017/08/11 04:50:40]

Yes, is seems like it might be useful to put into messages.yaml for consistency.
I will try to do this in the future.

+      'Another computeDelta() invocation is still executing.';

[Siggi Cherem (dart-lang), 2017/08/11 00:44:52]

Consider: Another => A

(since now this message is also shown when you call acceptLastDelta())

[scheglov, 2017/08/11 04:50:40]

Done.

+
+  static const MSG_NO_LAST_DELTA =
+      'The last delta has been already accepted or rejected.';
+
+  static const MSG_HAS_LAST_DELTA =
+      'The last delta must be either accepted or rejected.';
 
   /// The logger to report compilation progress.
   final PerformanceLog _logger;
 
   /// 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 20 matching lines @@
   _TestView get test => _testView;
 
   @override
   void acceptLastDelta() {
     _throwIfNoLastDelta();
     _currentSignatures.addAll(_lastSignatures);
     _lastSignatures = null;
   }
 
   @override
-  Future<DeltaProgram> computeDelta() async {
+  Future<DeltaProgram> computeDelta() {
+    if (_isComputeDeltaExecuting) {
+      throw new StateError(MSG_PENDING_COMPUTE);
+    }
+
     if (_lastSignatures != null) {
-      throw new StateError(
-          'The last delta must be either accepted or rejected.');
+      throw new StateError(MSG_HAS_LAST_DELTA);
     }
     _lastSignatures = {};
 
-    return await _logger.runAsync('Compute delta', () async {
-      KernelResult kernelResult = await _driver.getKernel(_entryPoint);
-      List<LibraryCycleResult> results = kernelResult.results;
+    _isComputeDeltaExecuting = true;
 
-      // The file graph might have changed, perform GC.
-      await _gc();
+    return _logger.runAsync('Compute delta', () async {
+      try {
+        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;
+            }
           }
         }
+
+        // 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;
       }
-
-      return new DeltaProgram(program);
     });
   }
 
   @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 (_isComputeDeltaExecuting) {
+      throw new StateError(MSG_PENDING_COMPUTE);
+    }
     if (_lastSignatures == null) {
-      throw new StateError(
-          'The last delta has been already accepted or rejected.');
+      throw new StateError(MSG_NO_LAST_DELTA);
     }
   }
 }
 
 @visibleForTesting
 class _TestView {
   final IncrementalKernelGeneratorImpl _generator;
 
   _TestView(this._generator);
 
   /// The [KernelDriver] that is used to actually compile.
   KernelDriver get driver => _generator._driver;
 }