Add interfaces for a new compiler API.

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, errors, warnings, etc.
 
 
 import 'dart:async';
 import 'dart:io' show Platform;
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 
-import 'package:compiler/compiler.dart' as api;
+import 'package:compiler/compiler.dart' as old_api;
+import 'package:compiler/compiler_new.dart' as api;
 import 'package:compiler/src/compile_time_constants.dart';
 import 'package:compiler/src/dart2js.dart' as entry;
 import 'package:compiler/src/dart2jslib.dart';
 import 'package:compiler/src/apiimpl.dart' as apiimpl;
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/library_loader.dart';
+import 'package:compiler/src/null_compiler_output.dart';
+import 'package:compiler/src/old_to_new_api.dart';
 import 'package:compiler/src/resolution/resolution.dart';
 import 'package:compiler/src/scanner/scannerlib.dart';
 import 'package:compiler/src/util/util.dart';
 
 class TestCompiler extends apiimpl.Compiler {
   final String testMarker;
   final String testType;
   final Function onTest;
 
-  TestCompiler(api.CompilerInputProvider inputProvider,
-                api.CompilerOutputProvider outputProvider,
-                api.DiagnosticHandler handler,
-                Uri libraryRoot,
-                Uri packageRoot,
-                List<String> options,
-                Map<String, dynamic> environment,
-                Uri packageConfig,
-                api.PackagesDiscoveryProvider findPackages,
-                String this.testMarker,
-                String this.testType,
-                Function this.onTest)
+  TestCompiler(api.CompilerInput inputProvider,
+               api.CompilerOutput outputProvider,
+               api.CompilerDiagnostics handler,
+               Uri libraryRoot,
+               Uri packageRoot,
+               List<String> options,
+               Map<String, dynamic> environment,
+               Uri packageConfig,
+               api.PackagesDiscoveryProvider findPackages,
+               String this.testMarker,
+               String this.testType,
+               Function this.onTest)
       : super(inputProvider, outputProvider, handler, libraryRoot,
               packageRoot, options, environment, packageConfig, findPackages) {
     scanner = new TestScanner(this);
     resolver = new TestResolver(this, backend.constantCompilerTask);
     test('Compiler');
   }
 
   Future<bool> run(Uri uri) {
     test('Compiler.run');
     return super.run(uri);
@@ skipping 91 matching lines @@
 Future testExitCode(
     String marker, String type, int expectedExitCode, List options) {
   bool testOccurred = false;
 
   void onTest(String testMarker, String testType) {
     if (testMarker == marker && testType == type) {
       testOccurred = true;
     }
   }
   return new Future(() {
-    Future<api.CompilationResult> compile(
+    Future<old_api.CompilationResult> compile(
         Uri script,
         Uri libraryRoot,
         Uri packageRoot,
-        api.CompilerInputProvider inputProvider,
-        api.DiagnosticHandler handler,
+        old_api.CompilerInputProvider inputProvider,
+        old_api.DiagnosticHandler handler,
         [List<String> options = const [],
-         api.CompilerOutputProvider outputProvider,
+         old_api.CompilerOutputProvider outputProvider,
          Map<String, dynamic> environment = const {},
          Uri packageConfig,
          api.PackagesDiscoveryProvider findPackages]) {
       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,
-                                           packageConfig,
-                                           findPackages,
-                                           marker,
-                                           type,
-                                           onTest);
+      Compiler compiler = new TestCompiler(
+          new LegacyCompilerInput(inputProvider),
+          new LegacyCompilerOutput(outputProvider),
+          new LegacyCompilerDiagnostics(handler),
+          libraryRoot,
+          packageRoot,
+          options,
+          environment,
+          packageConfig,
+          findPackages,
+          marker,
+          type,
+          onTest);
       return compiler.run(script).then((bool success) {
-        return new api.CompilationResult(compiler, isSuccess: success);
+        return new old_api.CompilationResult(compiler, isSuccess: success);
       });
     }
 
     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');
@@ skipping 77 matching lines @@
 
       expected = _expectedExitCode(
           beforeRun: tests[marker], fatalWarnings: true);
       totalExpectedErrors += expected.length;
       await testExitCodes(marker, expected, ['--fatal-warnings']);
     }
 
     Expect.equals(totalExpectedErrors, checkedResults);
   });
 }