Update DeltaProgram API and documentation.

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:front_end/compiler_options.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/memory_file_system.dart';
 import 'package:kernel/ast.dart';
@@ skipping 10 matching lines @@
 }
 
 @reflectiveTest
 class IncrementalKernelGeneratorTest {
   /// Virtual filesystem for testing.
   final fileSystem = new MemoryFileSystem(Uri.parse('file:///'));
 
   /// The object under test.
   IncrementalKernelGenerator incrementalKernelGenerator;
 
-  /// TODO(scheglov) Why do we return a Map?
-  /// From the discussion yesterday it seems to me that we always have
-  /// just one program - with all libraries with code, or with some libraries
-  /// with code and some with only outlines.
-  Future<Map<Uri, Program>> getInitialState(Uri entryPoint) async {
+  /// Compute the initial [Program] for the given [entryPoint].
+  Future<Program> getInitialState(Uri entryPoint) async {
     Map<String, Uri> dartLibraries = createSdkFiles(fileSystem);
     // TODO(scheglov) Builder the SDK kernel and set it into the options.
 
     // TODO(scheglov) Make `.packages` file optional.
 
     incrementalKernelGenerator = new IncrementalKernelGenerator(
         entryPoint,
         new CompilerOptions()
           ..fileSystem = fileSystem
           ..strongMode = true
           ..chaseDependencies = true
           ..dartLibraries = dartLibraries
           ..packagesFileUri = Uri.parse('file:///test/.packages'));
-    return (await incrementalKernelGenerator.computeDelta()).newState;
+    return (await incrementalKernelGenerator.computeDelta()).newProgram;
   }
 
   test_updateEntryPoint() async {
     writeFile('/test/.packages', 'test:lib/');
     String path = '/test/lib/test.dart';
     Uri uri = writeFile(
         path,
         r'''
 main() {
   var v = 1;
 }
 ''');
 
     // Compute the initial state
     {
-      Map<Uri, Program> initialState = await getInitialState(uri);
-      expect(initialState.keys, unorderedEquals([uri]));
-
-      Library library = _getLibrary(initialState[uri], uri);
+      Program program = await getInitialState(uri);
+      Library library = _getLibrary(program, uri);
       expect(
           _getLibraryText(library),
           r'''
 library;
 import self as self;
 import "dart:core" as core;
 
 static method main() → dynamic {
   core::int v = 1;
 }
 ''');
     }
 
     // Update the entry point library.
     writeFile(
         path,
         r'''
 main() {
   var v = 2.3;
 }
 ''');
 
     // The delta has the updated entry point library.
     {
       DeltaProgram delta = await incrementalKernelGenerator.computeDelta();
-      expect(delta.newState.keys, unorderedEquals([uri]));
-
-      Library library = _getLibrary(delta.newState[uri], uri);
+      Program program = delta.newProgram;
+      Library library = _getLibrary(program, uri);
       expect(
           _getLibraryText(library),
           r'''
 library;
 import self as self;
 import "dart:core" as core;
 
 static method main() → dynamic {
   core::double v = 2.3;
 }
@@ skipping 42 matching lines @@
     throw fail('No library found with URI "$uri"');
   }
 
   String _getLibraryText(Library library) {
     StringBuffer buffer = new StringBuffer();
     new Printer(buffer, syntheticNames: new NameSystem())
         .writeLibraryFile(library);
     return buffer.toString();
   }
 }