Revert "Remove Compiler.assembledCode."

pkg/compiler/lib/src/dart2js.dart

 // Copyright (c) 2013, 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 dart2js.cmdline;
 
 import 'dart:async'
     show Future, EventSink;
 import 'dart:convert' show UTF8, LineSplitter;
 import 'dart:io'
@@ skipping 82 matching lines @@
         }
         continue OUTER;
       }
     }
     throw 'Internal error: "$argument" did not match';
   }
 }
 
 FormattingDiagnosticHandler diagnosticHandler;
 
-Future<api.CompilationResult> compile(List<String> argv) {
+Future compile(List<String> argv) {
   stackTraceFilePrefix = '$currentDirectory';
   Uri libraryRoot = currentDirectory;
   Uri out = currentDirectory.resolve('out.js');
   Uri sourceMapOut = currentDirectory.resolve('out.js.map');
   Uri packageRoot = null;
   List<String> options = new List<String>();
   bool explicitOut = false;
   bool wantHelp = false;
   bool wantVersion = false;
   String outputLanguage = 'JavaScript';
@@ skipping 301 matching lines @@
 
   diagnosticHandler.info('Package root is $packageRoot');
 
   options.add('--out=$out');
   options.add('--source-map=$sourceMapOut');
 
   RandomAccessFileOutputProvider outputProvider =
       new RandomAccessFileOutputProvider(
           out, sourceMapOut, onInfo: diagnosticHandler.info, onFailure: fail);
 
-  api.CompilationResult compilationDone(api.CompilationResult result) {
-    if (analyzeOnly) return result;
-    if (!result.isSuccess) {
+  compilationDone(String code) {
+    if (analyzeOnly) return;
+    if (code == null) {
       fail('Compilation failed.');
     }
     writeString(Uri.parse('$out.deps'),
                 getDepsOutput(inputProvider.sourceFiles));
     diagnosticHandler.info(
          'Compiled ${inputProvider.dartCharactersRead} characters Dart '
          '-> ${outputProvider.totalCharactersWritten} characters '
          '$outputLanguage in '
          '${relativize(currentDirectory, out, Platform.isWindows)}');
     if (diagnosticHandler.verbose) {
       String input = uriPathToNative(arguments[0]);
       print('Dart file ($input) compiled to $outputLanguage.');
       print('Wrote the following files:');
       for (String filename in outputProvider.allOutputFiles) {
         print("  $filename");
       }
     } else if (!explicitOut) {
       String input = uriPathToNative(arguments[0]);
       String output = relativize(currentDirectory, out, Platform.isWindows);
       print('Dart file ($input) compiled to $outputLanguage: $output');
     }
-    return result;
   }
 
   return compileFunc(uri, libraryRoot, packageRoot,
                      inputProvider, diagnosticHandler,
                      options, outputProvider, environment)
             .then(compilationDone);
 }
 
 class AbortLeg {
   final message;
@@ skipping 13 matching lines @@
 void fail(String message) {
   if (diagnosticHandler != null) {
     diagnosticHandler.diagnosticHandler(
         null, -1, -1, message, api.Diagnostic.ERROR);
   } else {
     print('Error: $message');
   }
   exitFunc(1);
 }
 
-Future<api.CompilationResult> compilerMain(List<String> arguments) {
+Future compilerMain(List<String> arguments) {
   var root = uriPathToNative("/$LIBRARY_ROOT");
   arguments = <String>['--library-root=${Platform.script.toFilePath()}$root']
       ..addAll(arguments);
   return compile(arguments);
 }
 
 void help() {
   // This message should be no longer than 20 lines. The default
   // terminal size normally 80x24. Two lines are used for the prompts
   // before and after running the compiler. Another two lines may be
@@ skipping 142 matching lines @@
   if (arguments.length > 0 && arguments.last == "--batch") {
     batchMain(arguments.sublist(0, arguments.length - 1));
     return;
   }
   internalMain(arguments);
 }
 
 var exitFunc = exit;
 var compileFunc = api.compile;
 
-Future<api.CompilationResult> internalMain(List<String> arguments) {
-  Future onError(exception, trace) {
+Future internalMain(List<String> arguments) {
+  onError(exception, trace) {
     try {
       print('The compiler crashed: $exception');
     } catch (ignored) {
       print('The compiler crashed: error while printing exception');
     }
 
     try {
       if (trace != null) {
         print(trace);
       }
     } finally {
       exitFunc(253); // 253 is recognized as a crash by our test scripts.
     }
-    return new Future.error(exception, trace);
   }
 
   try {
     return compilerMain(arguments).catchError(onError);
   } catch (exception, trace) {
-    return onError(exception, trace);
+    onError(exception, trace);
+    return new Future.value();
   }
 }
 
 const _EXIT_SIGNAL = const Object();
 
 void batchMain(List<String> batchArguments) {
   int exitCode;
   exitFunc = (errorCode) {
     // Since we only throw another part of the compiler might intercept our
     // exception and try to exit with a different code.
@@ skipping 26 matching lines @@
       } else if (exitCode == 253) {
         print(">>> TEST CRASH");
       } else {
         print(">>> TEST FAIL");
       }
       stderr.writeln(">>> EOF STDERR");
       subscription.resume();
     });
   });
 }