Fix incremental kernel builder to handle multiple calls to computeDelta.

pkg/front_end/test/incremental_kernel_generator_test.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:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:front_end/compiler_options.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
@@ skipping 14 matching lines @@
 List<int> _readSdkSummary() {
   var resourceProvider = PhysicalResourceProvider.INSTANCE;
   var sdk = new FolderBasedDartSdk(resourceProvider,
       FolderBasedDartSdk.defaultSdkDirectory(resourceProvider))
     ..useSummary = true;
   var path = resourceProvider.pathContext
       .join(sdk.directory.path, 'lib', '_internal', 'strong.sum');
   return resourceProvider.getFile(path).readAsBytesSync();
 }
 
+typedef void LibraryChecker(Library lib);
+
 @reflectiveTest
 class IncrementalKernelGeneratorTest {
   static final sdkSummaryUri = Uri.parse('special:sdk_summary');
 
   /// Virtual filesystem for testing.
   final fileSystem = new MemoryFileSystem(pathos.posix, Uri.parse('file:///'));
 
   /// The object under test.
   IncrementalKernelGenerator incrementalKernelGenerator;
 
+  void checkLibraries(
+      List<Library> libraries, Map<Uri, LibraryChecker> expected) {
+    expect(
+        libraries.map((lib) => lib.importUri), unorderedEquals(expected.keys));
+    var librariesMap = <Uri, Library>{};
+    for (var lib in libraries) {
+      librariesMap[lib.importUri] = lib;
+    }
+    expected.forEach((uri, checker) => checker(librariesMap[uri]));
+  }
+
   Future<Map<Uri, Program>> getInitialState(Uri startingUri) async {
     fileSystem.entityForUri(sdkSummaryUri).writeAsBytesSync(_sdkSummary);
     incrementalKernelGenerator = new IncrementalKernelGenerator(
         startingUri,
         new CompilerOptions()
           ..fileSystem = fileSystem
           ..chaseDependencies = true
           ..sdkSummary = sdkSummaryUri
           ..packagesFileUri = new Uri());
     return (await incrementalKernelGenerator.computeDelta()).newState;
   }
 
-  test_emptyProgram() async {
-    writeFiles({'/foo.dart': 'main() {}'});
+  test_incrementalUpdate_referenceToCore() async {
+    // TODO(paulberry): test parts.
+    writeFiles({'/foo.dart': 'main() { print(1); }'});
     var fileUri = Uri.parse('file:///foo.dart');
     var initialState = await getInitialState(fileUri);
     expect(initialState.keys, unorderedEquals([fileUri]));
-    var program = initialState[fileUri];
-    expect(program.libraries, hasLength(1));
-    var library = program.libraries[0];
-    expect(library.importUri, fileUri);
-    expect(library.classes, isEmpty);
-    expect(library.procedures, hasLength(1));
-    expect(library.procedures[0].name.name, 'main');
-    var body = library.procedures[0].function.body;
-    expect(body, new isInstanceOf<Block>());
-    var block = body as Block;
-    expect(block.statements, isEmpty);
+    void _checkMain(List<Library> libraries, int expectedArgument) {
+      checkLibraries(libraries, {
+        fileUri: (library) {
+          expect(library.importUri, fileUri);
+          expect(library.classes, isEmpty);
+          expect(library.procedures, hasLength(1));
+          expect(library.procedures[0].name.name, 'main');
+          var body = library.procedures[0].function.body;
+          expect(body, new isInstanceOf<Block>());
+          var block = body as Block;
+          expect(block.statements, hasLength(1));
+          expect(block.statements[0], new isInstanceOf<ExpressionStatement>());
+          var expressionStatement = block.statements[0] as ExpressionStatement;
+          expect(expressionStatement.expression,
+              new isInstanceOf<StaticInvocation>());
+          var staticInvocation =
+              expressionStatement.expression as StaticInvocation;
+          expect(staticInvocation.target.name.name, 'print');
+          expect(staticInvocation.arguments.positional, hasLength(1));
+          expect(staticInvocation.arguments.positional[0],
+              new isInstanceOf<IntLiteral>());
+          var intLiteral =
+              staticInvocation.arguments.positional[0] as IntLiteral;
+          expect(intLiteral.value, expectedArgument);
+        },
+        Uri.parse('dart:core'): (library) {
+          // Should contain the procedure "print" but not its definition.
+          expect(library.procedures, hasLength(1));
+          expect(library.procedures[0].name.name, 'print');
+          expect(library.procedures[0].function.body, isNull);
+        }
+      });
+    }
+
+    _checkMain(initialState[fileUri].libraries, 1);
+    writeFiles({'/foo.dart': 'main() { print(2); }'});
+    incrementalKernelGenerator.invalidateAll();
+    var deltaProgram = await incrementalKernelGenerator.computeDelta();
+    expect(deltaProgram.newState.keys, unorderedEquals([fileUri]));
+    _checkMain(deltaProgram.newState[fileUri].libraries, 2);
   }
 
   /// Write the given file contents to the virtual filesystem.
   void writeFiles(Map<String, String> contents) {
     contents.forEach((path, text) {
       fileSystem
           .entityForUri(Uri.parse('file://$path'))
           .writeAsStringSync(text);
     });
   }
 }