Make dart2js unittests async.

tests/compiler/dart2js/mock_compiler.dart

 // Copyright (c) 2012, 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.
 
 library mock_compiler;
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import 'dart:collection';
 
@@ skipping 245 matching lines @@
   List<WarningMessage> infos;
   List<WarningMessage> crashes;
   /// Expected number of warnings. If `null`, the number of warnings is
   /// not checked.
   final int expectedWarnings;
   /// Expected number of errors. If `null`, the number of errors is not checked.
   final int expectedErrors;
   final Map<String, SourceFile> sourceFiles;
   Node parsedTree;
 
-  MockCompiler({String coreSource: DEFAULT_CORELIB,
-                String helperSource: DEFAULT_HELPERLIB,
-                String interceptorsSource: DEFAULT_INTERCEPTORSLIB,
-                String isolateHelperSource: DEFAULT_ISOLATE_HELPERLIB,
-                bool enableTypeAssertions: false,
-                bool enableMinification: false,
-                bool enableConcreteTypeInference: false,
-                int maxConcreteTypeSize: 5,
-                bool disableTypeInference: false,
-                bool analyzeAll: false,
-                bool analyzeOnly: false,
-                bool emitJavaScript: true,
-                bool preserveComments: false,
-                // Our unit tests check code generation output that is
-                // affected by inlining support.
-                bool disableInlining: true,
-                int this.expectedWarnings,
-                int this.expectedErrors})
+  MockCompiler.internal(
+      {String coreSource: DEFAULT_CORELIB,
+       String helperSource: DEFAULT_HELPERLIB,
+       String interceptorsSource: DEFAULT_INTERCEPTORSLIB,
+       String isolateHelperSource: DEFAULT_ISOLATE_HELPERLIB,
+       bool enableTypeAssertions: false,
+       bool enableMinification: false,
+       bool enableConcreteTypeInference: false,
+       int maxConcreteTypeSize: 5,
+       bool disableTypeInference: false,
+       bool analyzeAll: false,
+       bool analyzeOnly: false,
+       bool emitJavaScript: true,
+       bool preserveComments: false,
+       // Our unit tests check code generation output that is
+       // affected by inlining support.
+       bool disableInlining: true,
+       int this.expectedWarnings,
+       int this.expectedErrors})
       : sourceFiles = new Map<String, SourceFile>(),
         super(enableTypeAssertions: enableTypeAssertions,
               enableMinification: enableMinification,
               enableConcreteTypeInference: enableConcreteTypeInference,
               maxConcreteTypeSize: maxConcreteTypeSize,
               disableTypeInferenceFlag: disableTypeInference,
               analyzeAllFlag: analyzeAll,
               analyzeOnly: analyzeOnly,
               emitJavaScript: emitJavaScript,
               preserveComments: preserveComments,
@@ skipping 24 matching lines @@
     // dynamic invocation the ArgumentTypesRegistry eventually iterates over
     // the interfaces of the Object class which would be 'null' if the class
     // wasn't resolved.
     objectClass.ensureResolved(this);
 
     this.disableInlining = disableInlining;
 
     deferredLoadTask = new MockDeferredLoadTask(this);
   }
 
+  /// Initialize the mock compiler with an empty main library.
+  Future init() {
+    // Stub for initialization.
+    return new Future.value();
+  }
+
   Future runCompiler(Uri uri) {
     return super.runCompiler(uri).then((result) {
       if (expectedErrors != null &&
           expectedErrors != errors.length) {
         throw "unexpected error during compilation ${errors}";
       } else if (expectedWarnings != null &&
                  expectedWarnings != warnings.length) {
         throw "unexpected warnings during compilation ${warnings}";
       } else {
         return result;
@@ skipping 129 matching lines @@
     if (sourceFile == null) throw new ArgumentError(uri);
     return new Future.value(new Script(uri, uri, sourceFile));
   }
 
   Element lookupElementIn(ScopeContainerElement container, name) {
     Element element = container.localLookup(name);
     return element != null
         ? element
         : new ErroneousElementX(null, null, name, container);
   }
+
+  /// Create a new [MockCompiler] and apply it asynchronously to [f].
+  static Future create(f(MockCompiler compiler)) {
+    MockCompiler compiler = new MockCompiler.internal();
+    return compiler.init().then((_) => f(compiler));
+  }
 }
 
 /// A function the checks [message]. If the check fails or if [message] is
 /// `null`, an error string is returned. Otherwise `null` is returned.
 typedef String CheckMessage(Message message);
 
 CheckMessage checkMessage(MessageKind kind, Map arguments) {
   return (Message message) {
     if (message == null) return '$kind';
     if (message.kind != kind) return 'Expected message $kind, found $message.';
@@ skipping 116 matching lines @@
 
 class MockElement extends FunctionElementX {
   MockElement(Element enclosingElement)
       : super('', ElementKind.FUNCTION, Modifiers.EMPTY,
               enclosingElement, false);
 
   get node => null;
 
   parseNode(_) => null;
 }