Change dart2js.dart to use compiler_new.dart

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 old_api;
 import 'package:compiler/compiler_new.dart' as api;
 import 'package:compiler/src/common/codegen.dart';
 import 'package:compiler/src/compile_time_constants.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/dart2js.dart' as entry;
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/diagnostics/invariant.dart';
 import 'package:compiler/src/diagnostics/messages.dart';
 import 'package:compiler/src/diagnostics/spannable.dart';
 import 'package:compiler/src/apiimpl.dart' as apiimpl;
 import 'package:compiler/src/enqueue.dart';
 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/options.dart' show CompilerOptions;
 import 'package:compiler/src/resolution/resolution.dart';
 import 'package:compiler/src/scanner/scanner_task.dart';
 import 'package:compiler/src/universe/world_impact.dart';
 import 'diagnostic_reporter_helper.dart';
 
 class TestCompiler extends apiimpl.CompilerImpl {
   final String testMarker;
   final String testType;
   final Function onTest;
   TestDiagnosticReporter reporter;
 
   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,
+               CompilerOptions options,
                String this.testMarker,
                String this.testType,
                Function this.onTest)
       : reporter = new TestDiagnosticReporter(),
-        super(inputProvider, outputProvider, handler,
-            new CompilerOptions.parse(
-                libraryRoot: libraryRoot,
-                packageRoot: packageRoot,
-                options: options,
-                environment: environment,
-                packageConfig: packageConfig,
-                packagesDiscoveryProvider: findPackages)) {
+        super(inputProvider, outputProvider, handler, options) {
     reporter.compiler = this;
     reporter.reporter = super.reporter;
     test('Compiler');
   }
 
   @override
   ScannerTask createScannerTask() => new TestScanner(this);
 
   @override
   ResolverTask createResolverTask() {
@@ skipping 106 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<old_api.CompilationResult> compile(
-        Uri script,
-        Uri libraryRoot,
-        Uri packageRoot,
-        old_api.CompilerInputProvider inputProvider,
-        old_api.DiagnosticHandler handler,
-        [List<String> options = const [],
-         old_api.CompilerOutputProvider outputProvider,
-         Map<String, dynamic> environment = const {},
-         Uri packageConfig,
-         api.PackagesDiscoveryProvider findPackages]) {
-      libraryRoot = Platform.script.resolve('../../../sdk/');
-      outputProvider = NullSink.outputProvider;
+    Future<api.CompilationResult> compile(
+        CompilerOptions compilerOptions,
+        api.CompilerInput compilerInput,
+        api.CompilerDiagnostics compilerDiagnostics,
+        api.CompilerOutput compilerOutput) {
+      compilerOutput = const NullCompilerOutput();
       // Use this to silence the test when debugging:
       // handler = (uri, begin, end, message, kind) {};
       Compiler compiler = new TestCompiler(
-          new LegacyCompilerInput(inputProvider),
-          new LegacyCompilerOutput(outputProvider),
-          new LegacyCompilerDiagnostics(handler),
-          libraryRoot,
-          packageRoot,
-          options,
-          environment,
-          packageConfig,
-          findPackages,
+          compilerInput,
+          compilerOutput,
+          compilerDiagnostics,
+          compilerOptions,
           marker,
           type,
           onTest);
-      return compiler.run(script).then((bool success) {
-        return new old_api.CompilationResult(compiler, isSuccess: success);
+      return compiler.run(compilerOptions.entryPoint).then((bool success) {
+        return new 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');
       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;
 
     List<String> args = new List<String>.from(options)
+        ..add("--library-root=${Platform.script.resolve('../../../sdk/')}")
         ..add("tests/compiler/dart2js/data/exit_code_helper.dart");
     Future result = entry.internalMain(args);
     return result.catchError((e, s) {
       // Capture crashes.
     }).whenComplete(checkResult);
   });
 }
 
 Future testExitCodes(
     String marker, Map<String,int> expectedExitCodes, List<String> options) {
@@ skipping 51 matching lines @@
 
       expected = _expectedExitCode(
           beforeRun: tests[marker], fatalWarnings: true);
       totalExpectedErrors += expected.length;
       await testExitCodes(marker, expected, ['--fatal-warnings']);
     }
 
     Expect.equals(totalExpectedErrors, checkedResults);
   });
 }