Rename buildOutline() and separate 'build' and 'writeProgram()'.

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 'dart:io';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/incremental_resolved_ast_generator.dart';
@@ skipping 155 matching lines @@
         Uri uri = library.uri;
         libraryUris.add(uri);
         libraryUriToFile[uri] = library;
       }
 
       Future<Null> appendNewDillLibraries(Program program) async {
         List<DillLibraryBuilder> libraryBuilders = dillTarget.loader
             .appendLibraries(program, (uri) => libraryUris.contains(uri));
 
         // Compute local scopes.
-        await dillTarget.computeOutline();
+        await dillTarget.buildOutlines();
 
         // Compute export scopes.
         _computeExportScopes(dillTarget, libraryUriToFile, libraryBuilders);
       }
 
       // Check if there is already a bundle with these libraries.
       List<int> bytes = _byteStore.get(kernelKey);
       if (bytes != null) {
         return _logger.runAsync('Read serialized libraries', () async {
           var program = new Program(nameRoot: nameRoot);
           var reader = new BinaryBuilder(bytes);
           reader.readProgram(program);
 
           await appendNewDillLibraries(program);
 
           return new _LibraryCycleResult(cycle, signature, program.libraries);
         });
       }
 
       // Create KernelTarget and configure it for compiling the cycle URIs.
       KernelTarget kernelTarget = new KernelTarget(_fsState.fileSystemView,
           dillTarget, _uriTranslator, _options.strongMode);
       for (FileState library in cycle.libraries) {
         kernelTarget.read(library.uri);
       }
 
       // Compile the cycle libraries into a new full program.
       Program program = await _logger
           .runAsync('Compile ${cycle.libraries.length} libraries', () async {
-        await kernelTarget.computeOutline(nameRoot: nameRoot);
-        return await kernelTarget.writeProgram(null);
+        await kernelTarget.buildOutlines(nameRoot: nameRoot);
+        return await kernelTarget.buildProgram();
       });
 
       // Add newly compiled libraries into DILL.
       await appendNewDillLibraries(program);
 
       List<Library> kernelLibraries = program.libraries
           .where((library) => libraryUris.contains(library.importUri))
           .toList();
 
       _logger.run('Serialize ${kernelLibraries.length} libraries', () {
@@ skipping 66 matching lines @@
   /// TODO(scheglov) Use API signatures.
   /// TODO(scheglov) Or use tree shaking and compute signatures of outlines.
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   _LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }