remove dependency on compiler from resolution

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_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';
@@ skipping 12 matching lines @@
 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,
-               CompilerOptions options,
-               String this.testMarker,
-               String this.testType,
-               Function this.onTest)
+  TestCompiler(
+      api.CompilerInput inputProvider,
+      api.CompilerOutput outputProvider,
+      api.CompilerDiagnostics handler,
+      CompilerOptions options,
+      String this.testMarker,
+      String this.testType,
+      Function this.onTest)
       : reporter = new TestDiagnosticReporter(),
         super(inputProvider, outputProvider, handler, options) {
     reporter.compiler = this;
     reporter.reporter = super.reporter;
     test('Compiler');
   }
 
   @override
   ScannerTask createScannerTask() => new TestScanner(this);
 
@@ skipping 23 matching lines @@
   }
 
   WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     test('Compiler.codegen');
     return super.codegen(work, world);
   }
 
   test(String marker) {
     if (marker == testMarker) {
       switch (testType) {
-      case 'assert':
-        onTest(testMarker, testType);
-        assert(false);
-        break;
-      case 'invariant':
-        onTest(testMarker, testType);
-        invariant(NO_LOCATION_SPANNABLE, false, message: marker);
-        break;
-      case 'warning':
-        onTest(testMarker, testType);
-        reporter.reportWarningMessage(
-            NO_LOCATION_SPANNABLE,
-            MessageKind.GENERIC, {'text': marker});
-        break;
-      case 'error':
-        onTest(testMarker, testType);
-        reporter.reportErrorMessage(
-            NO_LOCATION_SPANNABLE,
-            MessageKind.GENERIC, {'text': marker});
-        break;
-      case 'internalError':
-        onTest(testMarker, testType);
-        reporter.internalError(NO_LOCATION_SPANNABLE, marker);
-        break;
-      case 'NoSuchMethodError':
-        onTest(testMarker, testType);
-        null.foo;
-        break;
-      case '':
-        onTest(testMarker, testType);
-        break;
+        case 'assert':
+          onTest(testMarker, testType);
+          assert(false);
+          break;
+        case 'invariant':
+          onTest(testMarker, testType);
+          invariant(NO_LOCATION_SPANNABLE, false, message: marker);
+          break;
+        case 'warning':
+          onTest(testMarker, testType);
+          reporter.reportWarningMessage(
+              NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {'text': marker});
+          break;
+        case 'error':
+          onTest(testMarker, testType);
+          reporter.reportErrorMessage(
+              NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {'text': marker});
+          break;
+        case 'internalError':
+          onTest(testMarker, testType);
+          reporter.internalError(NO_LOCATION_SPANNABLE, marker);
+          break;
+        case 'NoSuchMethodError':
+          onTest(testMarker, testType);
+          null.foo;
+          break;
+        case '':
+          onTest(testMarker, testType);
+          break;
       }
     }
   }
 }
 
 class TestDiagnosticReporter extends DiagnosticReporterWrapper {
   TestCompiler compiler;
   DiagnosticReporter reporter;
 
   @override
@@ skipping 12 matching lines @@
       : compiler = compiler,
         super(compiler.dietParser, compiler.reporter, compiler.measurer);
 
   void scanElements(CompilationUnitElement compilationUnit) {
     compiler.test('ScannerTask.scanElements');
     super.scanElements(compilationUnit);
   }
 }
 
 class TestResolver extends ResolverTask {
+  final TestCompiler _compiler;
   TestResolver(TestCompiler compiler, ConstantCompiler constantCompiler)
-      : super(compiler, constantCompiler);
+      : this._compiler = compiler,
+        super(compiler.resolution, constantCompiler, compiler.world,
+            compiler.measurer);
 
-  TestCompiler get compiler => super.compiler;
+  TestCompiler get compiler => this._compiler;
 
   void computeClassMembers(ClassElement element) {
     compiler.test('ResolverTask.computeClassMembers');
     super.computeClassMembers(element);
   }
 }
 
 int checkedResults = 0;
 
 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(
         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(
-          compilerInput,
-          compilerOutput,
-          compilerDiagnostics,
-          compilerOptions,
-          marker,
-          type,
-          onTest);
+      Compiler compiler = new TestCompiler(compilerInput, compilerOutput,
+          compilerDiagnostics, compilerOptions, marker, type, onTest);
       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,
+          '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");
+      ..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) {
+    String marker, Map<String, int> expectedExitCodes, List<String> options) {
   return Future.forEach(expectedExitCodes.keys, (String type) {
     return testExitCode(marker, type, expectedExitCodes[type], options);
   });
 }
 
 void main() {
   bool isCheckedMode = false;
   assert((isCheckedMode = true));
 
   Map _expectedExitCode({bool beforeRun: false, bool fatalWarnings: false}) {
@@ skipping 32 matching lines @@
     'ResolverTask.computeClassMembers': duringRun,
   };
   int totalExpectedErrors = 0;
 
   asyncTest(() async {
     for (String marker in tests.keys) {
       var expected = _expectedExitCode(beforeRun: tests[marker]);
       totalExpectedErrors += expected.length;
       await testExitCodes(marker, expected, []);
 
-      expected = _expectedExitCode(
-          beforeRun: tests[marker], fatalWarnings: true);
+      expected =
+          _expectedExitCode(beforeRun: tests[marker], fatalWarnings: true);
       totalExpectedErrors += expected.length;
       await testExitCodes(marker, expected, ['--fatal-warnings']);
     }
 
     Expect.equals(totalExpectedErrors, checkedResults);
   });
 }