Add IncrementalKernelGenerator.acceptLastDelta()/rejectLastDelta().

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;
 
-  /// Latest compilation signatures produced by [computeDelta] for libraries.
-  final Map<Uri, String> _latestSignature = {};
+  /// 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;
 
   IncrementalKernelGeneratorImpl(ProcessedOptions options,
       UriTranslator uriTranslator, List<int> sdkOutlineBytes, this._entryPoint,
       {WatchUsedFilesFn watch})
       : _logger = options.logger,
         _watchFn = watch {
     _testView = new _TestView(this);
 
     Future<Null> onFileAdded(Uri uri) {
       if (_watchFn != null) {
         return _watchFn(uri, true);
       }
       return new Future.value();
     }
 
     _driver = new KernelDriver(options, uriTranslator,
         sdkOutlineBytes: sdkOutlineBytes, fileAddedFn: onFileAdded);
   }
 
   /// Return the object that provides additional information for tests.
   @visibleForTesting
   _TestView get test => _testView;
 
   @override
+  void acceptLastDelta() {
+    _throwIfNoLastDelta();
+    _currentSignatures.addAll(_lastSignatures);
+    _lastSignatures = null;
+  }
+
+  @override
   Future<DeltaProgram> computeDelta() async {
+    if (_lastSignatures != null) {
+      throw new StateError(

[Siggi Cherem (dart-lang), 2017/08/10 18:31:15]

question: instead of throwing, should we instead report an error message via
options.reportError? (and define an error in messages.yaml)?

[scheglov, 2017/08/10 19:28:39]

I don't know.

Outside of front_end I would use StateError, because nothing good is going to
happen when you use API incorrectly.
It is not a compilation error, or a transient problem - it is a programmer
error.

+          'The last delta must be either accepted or rejected.');
+    }
+    _lastSignatures = {};

[Siggi Cherem (dart-lang), 2017/08/10 18:31:15]

it might be good to also enforce that accept/reject is not called until after
computeDelta() completes. 
Two ideas for that:
- we could keep this as a local variable and only assign it as a field when you
are about to return the DeltaProgram
- add a second field to track that there is a computeDelta in progress.

Also, since you said that calling `invalidate` is invalid if there is a pending
computeDelta, we might want to do that too. If so, I guess the latter idea might
make more sense.

[scheglov, 2017/08/10 19:28:39]

This is not a new contract, I will return to enforcement in a new CL.

+
     return await _logger.runAsync('Compute delta', () async {
       KernelResult kernelResult = await _driver.getKernel(_entryPoint);
       List<LibraryCycleResult> results = kernelResult.results;
 
       // 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 (_latestSignature[uri] != result.signature) {
-            _latestSignature[uri] = result.signature;
+          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>();
 
@@ skipping 30 matching lines @@
 
       return new DeltaProgram(program);
     });
   }
 
   @override
   void invalidate(Uri uri) {
     _driver.invalidate(uri);
   }
 
+  @override
+  void rejectLastDelta() {
+    _throwIfNoLastDelta();
+    _lastSignatures = null;
+  }
+
   /// TODO(scheglov) document
   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) {
+      throw new StateError(
+          'The last delta has been already accepted or rejected.');

[Siggi Cherem (dart-lang), 2017/08/10 18:31:15]

same question: report or throw?

+    }
+  }
 }
 
 @visibleForTesting
 class _TestView {
   final IncrementalKernelGeneratorImpl _generator;
 
   _TestView(this._generator);
 
   /// The [KernelDriver] that is used to actually compile.
   KernelDriver get driver => _generator._driver;
 }