Move writeOutline() and writeProgram() out of KernelTarget.

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;
+import 'dart:io' show File;
 
 import 'package:front_end/file_system.dart';
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
         CanonicalName,
         Class,
         Constructor,
         DartType,
@@ skipping 14 matching lines @@
         Program,
         Source,
         StringLiteral,
         SuperInitializer,
         Throw,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
-import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
-
 import 'package:kernel/transformations/erasure.dart' show Erasure;
 
 import 'package:kernel/transformations/continuation.dart' as transformAsync;
 
 import 'package:kernel/transformations/mixin_full_resolution.dart'
     show MixinFullResolution;
 
 import 'package:kernel/type_algebra.dart' show substitute;
 
 import '../source/source_loader.dart' show SourceLoader;
@@ skipping 154 matching lines @@
     cls.implementedTypes.clear();
     cls.supertype = null;
     cls.mixedInType = null;
     builder.supertype = new KernelNamedTypeBuilder("Object", null,
         builder.charOffset, builder.fileUri ?? Uri.parse(cls.fileUri))
       ..builder = objectClassBuilder;
     builder.interfaces = null;
     builder.mixedInType = null;
   }
 
-  Future<Program> handleInputError(Uri uri, InputError error,
-      {bool isFullProgram}) {
+  void handleInputError(InputError error, {bool isFullProgram}) {
     if (error != null) {
       String message = error.format();
       print(message);
       errors.add(message);
     }
     _program = erroneousProgram(isFullProgram);
-    return uri == null
-        ? new Future<Program>.value(_program)
-        : writeLinkedProgram(uri, _program, isFullProgram: isFullProgram);
   }
 
   @override
   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 =
           link(new List<Library>.from(loader.libraries), nameRoot: nameRoot);
       loader.computeHierarchy(_program);
       loader.checkOverrides(sourceClasses);
       loader.prepareInitializerInference();
       loader.performInitializerInference();
-      return _program;
     } on InputError catch (e) {
-      return handleInputError(null, e, isFullProgram: false);
+      handleInputError(e, isFullProgram: false);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
-  }
-
-  Future<Null> writeOutline(Uri uri) async {
-    try {
-      if (uri != null) {
-        await writeLinkedProgram(uri, _program, isFullProgram: false);
-      }
-    } on InputError catch (e) {
-      handleInputError(uri, e, isFullProgram: false);
-    } catch (e, s) {
-      reportCrash(e, s, loader?.currentUriForCrashReporting);
-    }
+    return _program;
   }
 
   @override
   Future<Program> buildProgram({bool verify: false}) async {
     if (loader.first == null) return null;
     if (errors.isNotEmpty) {
-      return handleInputError(null, null, isFullProgram: true);
+      handleInputError(null, isFullProgram: true);
+      return _program;
     }
     try {
       await loader.buildBodies();
       loader.finishStaticInvocations();
       finishAllConstructors();
       loader.finishNativeMethods();
       runBuildTransformations();
 
       if (verify) this.verify();
       errors.addAll(loader.collectCompileTimeErrors().map((e) => e.format()));
       if (errors.isNotEmpty) {
-        return handleInputError(null, null, isFullProgram: true);
+        handleInputError(null, isFullProgram: true);
       }
-      return _program;
     } on InputError catch (e) {
-      return handleInputError(null, e, isFullProgram: true);
+      handleInputError(e, isFullProgram: true);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
-  }
-
-  Future<Null> writeProgram(Uri uri) async {
-    if (loader.first == null) return null;
-    try {
-      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);
-    }
+    return _program;
   }
 
   Future writeDepsFile(Uri output, Uri depsFile,
       {Iterable<Uri> extraDependencies}) async {
     String toRelativeFilePath(Uri uri) {
       // Ninja expects to find file names relative to the current working
       // directory. We've tried making them relative to the deps file, but that
       // doesn't work for downstream projects. Making them absolute also
       // doesn't work.
       //
@@ skipping 87 matching lines @@
         program.mainMethod = builder.procedure;
       }
     }
     if (errors.isEmpty || dillTarget.isLoaded) {
       runLinkTransformations(program);
     }
     ticker.logMs("Linked program");
     return program;
   }
 
-  Future<Program> writeLinkedProgram(Uri uri, Program program,
-      {bool isFullProgram}) async {
-    File output = new File.fromUri(uri);
-    IOSink sink = output.openWrite();
-    try {
-      new BinaryPrinter(sink).writeProgramFile(program);
-      program.unbindCanonicalNames();
-    } finally {
-      await sink.close();
-    }
-    if (isFullProgram) {
-      ticker.logMs("Wrote program to ${uri.toFilePath()}");
-    } else {
-      ticker.logMs("Wrote outline to ${uri.toFilePath()}");
-    }
-    return null;
-  }
-
   void installDefaultSupertypes() {
     Class objectClass = this.objectClass;
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
       library.forEach((String name, Builder builder) {
         if (builder is SourceClassBuilder) {
           Class cls = builder.target;
           if (cls != objectClass) {
             cls.supertype ??= objectClass.asRawSupertype;
           }
           if (builder.isMixinApplication) {
@@ skipping 284 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }