Revert "Remove Compiler.assembledCode."

tests/compiler/dart2js/exit_code_test.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.
 
 // Test the exit code of dart2js in case of exceptions, fatal errors, errors,
 // warnings, etc.
 
 
 import 'dart:async';
 import 'dart:io' show Platform;
@@ skipping 134 matching lines @@
 
 Future testExitCode(String marker, String type, int expectedExitCode) {
   bool testOccurred = false;
 
   void onTest(String testMarker, String testType) {
     if (testMarker == marker && testType == type) {
       testOccurred = true;
     }
   }
   return new Future(() {
-    Future<api.CompilationResult> compile(
-        Uri script,
-        Uri libraryRoot,
-        Uri packageRoot,
-        api.CompilerInputProvider inputProvider,
-        api.DiagnosticHandler handler,
-        [List<String> options = const [],
-         api.CompilerOutputProvider outputProvider,
-         Map<String, dynamic> environment = const {}]) {
+    Future<String> compile(Uri script,
+                           Uri libraryRoot,
+                           Uri packageRoot,
+                           api.CompilerInputProvider inputProvider,
+                           api.DiagnosticHandler handler,
+                           [List<String> options = const [],
+                            api.CompilerOutputProvider outputProvider,
+                            Map<String, dynamic> environment = const {}]) {
       libraryRoot = Platform.script.resolve('../../../sdk/');
       outputProvider = NullSink.outputProvider;
       // Use this to silence the test when debugging:
       // handler = (uri, begin, end, message, kind) {};
       Compiler compiler = new TestCompiler(inputProvider,
                                            outputProvider,
                                            handler,
                                            libraryRoot,
                                            packageRoot,
                                            options,
                                            environment,
                                            marker,
                                            type,
                                            onTest);
-      return compiler.run(script).then((bool success) {
-        return new api.CompilationResult(compiler, isSuccess: success);
+      return compiler.run(script).then((_) {
+        String code = compiler.assembledCode;
+        if (code != null && outputProvider != null) {
+          String outputType = 'js';
+          if (options.contains('--output-type=dart')) {
+            outputType = 'dart';
+          }
+          outputProvider('', outputType)
+              ..add(code)
+              ..close();
+          code = ''; // Non-null signals success.
+        }
+        return code;
       });
     }
 
     int foundExitCode;
 
     checkResult() {
       Expect.isTrue(testOccurred, 'testExitCode($marker, $type) did not occur');
       if (foundExitCode == null) foundExitCode = 0;
       print('testExitCode($marker, $type) '
             'exitCode=$foundExitCode expected=$expectedExitCode');
       Expect.equals(expectedExitCode, foundExitCode,
           'testExitCode($marker, $type) '
           'exitCode=$foundExitCode expected=${expectedExitCode}');
       checkedResults++;
     }
 
     void exit(exitCode) {
       if (foundExitCode == null) {
         foundExitCode = exitCode;
       }
     };
 
     entry.exitFunc = exit;
     entry.compileFunc = compile;
 
     Future result = entry.internalMain(
         ["tests/compiler/dart2js/exit_code_helper.dart"]);
-    return result.catchError((e, s) {
-      // Capture crashes.
-    }).whenComplete(checkResult);
+    return result.whenComplete(checkResult);
   });
 }
 
 Future testExitCodes(String marker, Map<String,int> expectedExitCodes) {
   return Future.forEach(expectedExitCodes.keys, (String type) {
     return testExitCode(marker, type, expectedExitCodes[type]);
   });
 }
 
 void main() {
@@ skipping 37 matching lines @@
     int countResults(Map runType) {
       return runType.length *
              tests.values.where((r) => r == runType).length;
     }
 
     Expect.equals(countResults(beforeRun) + countResults(duringRun),
                   checkedResults);
     asyncEnd();
   });
 }