Decouple WorkItem from Compiler

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/backend_api.dart';
 import 'package:compiler/src/common/codegen.dart';
+import 'package:compiler/src/common/resolution.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/js_backend/js_backend.dart';
 import 'package:compiler/src/library_loader.dart';
 import 'package:compiler/src/null_compiler_output.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;
@@ skipping 10 matching lines @@
       String this.testType,
       Function this.onTest)
       : reporter = new TestDiagnosticReporter(),
         super(inputProvider, outputProvider, handler, options) {
     reporter.compiler = this;
     reporter.reporter = super.reporter;
     test('Compiler');
   }
 
   @override
+  Backend createBackend() {
+    return new TestBackend(this);
+  }
+
+  @override
   ScannerTask createScannerTask() => new TestScanner(this);
 
   @override
+  Resolution createResolution() => new TestResolution(this);
+
+  @override
   ResolverTask createResolverTask() {
     return new TestResolver(this, backend.constantCompilerTask);
   }
 
   Future<bool> run(Uri uri) {
     test('Compiler.run');
     return super.run(uri);
   }
 
   Future onLibraryScanned(LibraryElement element, LibraryLoader loader) {
     test('Compiler.onLibraryScanned');
     return super.onLibraryScanned(element, loader);
   }
 
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     test('Compiler.onLibrariesLoaded');
     return super.onLibrariesLoaded(loadedLibraries);
   }
 
-  WorldImpact analyzeElement(Element element) {
-    test('Compiler.analyzeElement');
-    return super.analyzeElement(element);
-  }
-
-  WorldImpact codegen(CodegenWorkItem work, Enqueuer 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);
@@ skipping 17 matching lines @@
           null.foo;
           break;
         case '':
           onTest(testMarker, testType);
           break;
       }
     }
   }
 }
 
+class TestBackend extends JavaScriptBackend {
+  final TestCompiler compiler;
+  TestBackend(TestCompiler compiler)
+      : this.compiler = compiler,
+        super(compiler,
+            generateSourceMap: compiler.options.generateSourceMap,
+            useStartupEmitter: compiler.options.useStartupEmitter,
+            useNewSourceInfo: compiler.options.useNewSourceInfo,
+            useKernel: compiler.options.useKernel);
+
+  @override
+  WorldImpact codegen(CodegenWorkItem work) {
+    compiler.test('Compiler.codegen');
+    return super.codegen(work);
+  }
+}
+
 class TestDiagnosticReporter extends DiagnosticReporterWrapper {
   TestCompiler compiler;
   DiagnosticReporter reporter;
 
   @override
   withCurrentElement(Element element, f()) {
     return super.withCurrentElement(element, () {
       compiler.test('Compiler.withCurrentElement');
       return f();
     });
@@ skipping 20 matching lines @@
       : this.compiler = compiler,
         super(compiler.resolution, constantCompiler, compiler.openWorld,
             compiler.measurer);
 
   void computeClassMembers(ClassElement element) {
     compiler.test('ResolverTask.computeClassMembers');
     super.computeClassMembers(element);
   }
 }
 
+class TestResolution extends CompilerResolution {
+  TestCompiler compiler;
+
+  TestResolution(TestCompiler compiler)
+      : this.compiler = compiler,
+        super(compiler);
+
+  @override
+  WorldImpact computeWorldImpact(Element element) {
+    compiler.test('Compiler.analyzeElement');
+    return super.computeWorldImpact(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;
     }
@@ skipping 107 matching lines @@
 
       expected =
           _expectedExitCode(beforeRun: tests[marker], fatalWarnings: true);
       totalExpectedErrors += expected.length;
       await testExitCodes(marker, expected, ['--fatal-warnings']);
     }
 
     Expect.equals(totalExpectedErrors, checkedResults);
   });
 }