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

pkg/front_end/lib/src/fasta/kernel/kernel_target.dart

 // Copyright (c) 2016, 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.
 
 library fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
@@ skipping 83 matching lines @@
   final FileSystem fileSystem;
 
   final bool strongMode;
 
   final DillTarget dillTarget;
 
   /// Shared with [CompilerContext].
   final Map<String, Source> uriToSource;
 
   SourceLoader<Library> loader;
-  Program program;
+  Program _program;
 
   final List errors = [];
 
   final TypeBuilder dynamicType =
       new KernelNamedTypeBuilder("dynamic", null, -1, null);
 
   KernelTarget(this.fileSystem, DillTarget dillTarget,
       TranslateUri uriTranslator, this.strongMode,
       [Map<String, Source> uriToSource])
       : dillTarget = dillTarget,
@@ skipping 103 matching lines @@
     builder.mixedInType = null;
   }
 
   Future<Program> handleInputError(Uri uri, InputError error,
       {bool isFullProgram}) {
     if (error != null) {
       String message = error.format();
       print(message);
       errors.add(message);
     }
-    program = erroneousProgram(isFullProgram);
+    _program = erroneousProgram(isFullProgram);
     return uri == null
-        ? new Future<Program>.value(program)
-        : writeLinkedProgram(uri, program, isFullProgram: isFullProgram);
+        ? new Future<Program>.value(_program)
+        : writeLinkedProgram(uri, _program, isFullProgram: isFullProgram);
   }
 
   @override
-  Future<Null> computeOutline({CanonicalName nameRoot}) async {
+  Future<Program> buildOutlines({CanonicalName nameRoot}) async {
     if (loader.first == null) return null;
     try {
       loader.createTypeInferenceEngine();
       await loader.buildOutlines();
       loader.coreLibrary
           .becomeCoreLibrary(const DynamicType(), const VoidType());
       dynamicType.bind(loader.coreLibrary["dynamic"]);
       loader.resolveParts();
       loader.computeLibraryScopes();
       loader.resolveTypes();
       loader.checkSemantics();
       loader.buildProgram();
       List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
       installDefaultSupertypes();
       installDefaultConstructors(sourceClasses);
       loader.resolveConstructors();
       loader.finishTypeVariables(objectClassBuilder);
-      program =
+      _program =
           link(new List<Library>.from(loader.libraries), nameRoot: nameRoot);
-      loader.computeHierarchy(program);
+      loader.computeHierarchy(_program);
       loader.checkOverrides(sourceClasses);
       loader.prepareInitializerInference();
       loader.performInitializerInference();
+      return _program;
     } on InputError catch (e) {
-      await handleInputError(null, e, isFullProgram: false);
+      return handleInputError(null, e, isFullProgram: false);
     } catch (e, s) {
-      await reportCrash(e, s, loader?.currentUriForCrashReporting);
+      return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
   }
 
   Future<Null> writeOutline(Uri uri) async {
     try {
       if (uri != null) {
-        await writeLinkedProgram(uri, program, isFullProgram: false);
+        await writeLinkedProgram(uri, _program, isFullProgram: false);
       }
     } on InputError catch (e) {
       handleInputError(uri, e, isFullProgram: false);
     } catch (e, s) {
       reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
   }
 
-  Future<Program> writeProgram(Uri uri,
-      {bool dumpIr: false, bool verify: false}) async {
+  @override
+  Future<Program> buildProgram() async {
     if (loader.first == null) return null;
     if (errors.isNotEmpty) {
-      return handleInputError(uri, null, isFullProgram: true);
+      return handleInputError(null, null, isFullProgram: true);
     }
     try {
       await loader.buildBodies();
       loader.finishStaticInvocations();
       finishAllConstructors();
       loader.finishNativeMethods();
       runBuildTransformations();
 
+      errors.addAll(loader.collectCompileTimeErrors().map((e) => e.format()));
+      if (errors.isNotEmpty) {
+        return handleInputError(null, null, isFullProgram: true);
+      }
+      return _program;
+    } on InputError catch (e) {
+      return handleInputError(null, e, isFullProgram: true);
+    } catch (e, s) {
+      return reportCrash(e, s, loader?.currentUriForCrashReporting);
+    }
+  }
+
+  Future<Null> writeProgram(Uri uri,
+      {bool dumpIr: false, bool verify: false}) async {
+    if (loader.first == null) return null;
+    try {
       if (dumpIr) this.dumpIr();
       if (verify) this.verify();
-      errors.addAll(loader.collectCompileTimeErrors().map((e) => e.format()));
-      if (errors.isNotEmpty) {
-        return handleInputError(uri, null, isFullProgram: true);
-      }
-      if (uri == null) return program;
-      return await writeLinkedProgram(uri, program, isFullProgram: true);
+      await writeLinkedProgram(uri, _program, isFullProgram: true);
     } on InputError catch (e) {
       return handleInputError(uri, e, isFullProgram: true);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
   }
 
   Future writeDepsFile(Uri output, Uri depsFile,
       {Iterable<Uri> extraDependencies}) async {
     String toRelativeFilePath(Uri uri) {
@@ skipping 375 matching lines @@
   /// first time.
   void runBuildTransformations() {
     transformMixinApplications();
     otherTransformations();
   }
 
   /// Run all transformations that are needed when linking a program.
   void runLinkTransformations(Program program) {}
 
   void transformMixinApplications() {
-    new MixinFullResolution().transform(program);
+    new MixinFullResolution().transform(_program);
     ticker.logMs("Transformed mixin applications");
   }
 
   void otherTransformations() {
     // TODO(ahe): Don't generate type variables in the first place.
     if (!strongMode) {
-      program.accept(new Erasure());
+      _program.accept(new Erasure());
       ticker.logMs("Erased type variables in generic methods");
     }
     // TODO(kmillikin): Make this run on a per-method basis.
-    transformAsync.transformProgram(program);
+    transformAsync.transformProgram(_program);
     ticker.logMs("Transformed async methods");
   }
 
   void dumpIr() {
     StringBuffer sb = new StringBuffer();
     for (Library library in loader.libraries) {
       Printer printer = new Printer(sb);
       printer.writeLibraryFile(library);
     }
     print("$sb");
     ticker.logMs("Dumped IR");
   }
 
   void verify() {
-    errors.addAll(verifyProgram(program));
+    errors.addAll(verifyProgram(_program));
     ticker.logMs("Verified program");
   }
 }
 
 /// Looks for a constructor call that matches `super()` from a constructor in
 /// [cls]. Such a constructor may have optional arguments, but no required
 /// arguments.
 Constructor defaultSuperConstructor(Class cls) {
   Class superclass = cls.superclass;
   while (superclass != null && superclass.isMixinApplication) {
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }