diff --git a/pkg/async_helper/lib/async_helper.dart b/pkg/async_helper/lib/async_helper.dart
index f1a84b369f7..72a391f03a0 100644
--- a/pkg/async_helper/lib/async_helper.dart
+++ b/pkg/async_helper/lib/async_helper.dart
@@ -61,3 +61,8 @@ void asyncEnd() {
     print('unittest-suite-success');
   }
 }
+
+void asyncTest(Future f()) {
+  asyncStart();
+  f().whenComplete(() => asyncEnd());
+}
\ No newline at end of file
diff --git a/sdk/lib/_internal/compiler/compiler.dart b/sdk/lib/_internal/compiler/compiler.dart
index abeb36c4594..215f248749e 100644
--- a/sdk/lib/_internal/compiler/compiler.dart
+++ b/sdk/lib/_internal/compiler/compiler.dart
@@ -92,19 +92,21 @@ Future<String> compile(Uri script,
                                    libraryRoot,
                                    packageRoot,
                                    options);
-  compiler.run(script);
-  String code = compiler.assembledCode;
-  if (code != null && outputProvider != null) {
-    String outputType = 'js';
-    if (options.contains('--output-type=dart')) {
-      outputType = 'dart';
+  // TODO(ahe): Use the value of the future (which signals success or failure).
+  return compiler.run(script).then((_) {
+    String code = compiler.assembledCode;
+    if (code != null && outputProvider != null) {
+      String outputType = 'js';
+      if (options.contains('--output-type=dart')) {
+        outputType = 'dart';
+      }
+      outputProvider('', outputType)
+          ..add(code)
+          ..close();
+      code = ''; // Non-null signals success.
     }
-    outputProvider('', outputType)
-        ..add(code)
-        ..close();
-    code = ''; // Non-null signals success.
-  }
-  return new Future.value(code);
+    return code;
+  });
 }
 
 /**
diff --git a/sdk/lib/_internal/compiler/implementation/apiimpl.dart b/sdk/lib/_internal/compiler/implementation/apiimpl.dart
index b15631a731f..d211e9415c0 100644
--- a/sdk/lib/_internal/compiler/implementation/apiimpl.dart
+++ b/sdk/lib/_internal/compiler/implementation/apiimpl.dart
@@ -133,12 +133,10 @@ class Compiler extends leg.Compiler {
     return "lib/$path";
   }
 
-  elements.LibraryElement scanBuiltinLibrary(String path) {
+  Future<elements.LibraryElement> scanBuiltinLibrary(String path) {
     Uri uri = libraryRoot.resolve(lookupLibraryPath(path));
     Uri canonicalUri = new Uri(scheme: "dart", path: path);
-    elements.LibraryElement library =
-        libraryLoader.loadLibrary(uri, null, canonicalUri);
-    return library;
+    return libraryLoader.loadLibrary(uri, null, canonicalUri);
   }
 
   void log(message) {
@@ -157,30 +155,37 @@ class Compiler extends leg.Compiler {
   /**
    * Reads the script designated by [readableUri].
    */
-  leg.Script readScript(Uri readableUri, [tree.Node node]) {
+  Future<leg.Script> readScript(Uri readableUri,
+                                [elements.Element element, tree.Node node]) {
     if (!readableUri.isAbsolute) {
       internalError('Relative uri $readableUri provided to readScript(Uri)',
                     node: node);
     }
-    return fileReadingTask.measure(() {
-      Uri resourceUri = translateUri(readableUri, node);
-      String text = "";
-      try {
-        // TODO(ahe): We expect the future to be complete and call value
-        // directly. In effect, we don't support truly asynchronous API.
-        text = deprecatedFutureValue(provider(resourceUri));
-      } catch (exception) {
+
+    // TODO(johnniwinther): Add [:report(..., {Element element}):] to
+    // report methods in Compiler.
+    void reportReadError(String exception) {
+      withCurrentElement(element, () {
         reportError(node,
                     leg.MessageKind.READ_SCRIPT_ERROR,
                     {'uri': readableUri, 'exception': exception});
-        return null;
-      }
+      });
+    }
+
+    Uri resourceUri = translateUri(readableUri, node);
+    // TODO(johnniwinther): Wrap the result from [provider] in a specialized
+    // [Future] to ensure that we never execute an asynchronous action without setting
+    // up the current element of the compiler.
+    return new Future.sync(() => provider(resourceUri)).then((String text) {
       SourceFile sourceFile = new SourceFile(resourceUri.toString(), text);
       // We use [readableUri] as the URI for the script since need to preserve
       // the scheme in the script because [Script.uri] is used for resolving
       // relative URIs mentioned in the script. See the comment on
       // [LibraryLoader] for more details.
       return new leg.Script(readableUri, sourceFile);
+    }).catchError((error) {
+      reportReadError(error);
+      return null;
     });
   }
 
@@ -254,18 +259,19 @@ class Compiler extends leg.Compiler {
     return packageRoot.resolve(uri.path);
   }
 
-  bool run(Uri uri) {
+  Future<bool> run(Uri uri) {
     log('Allowed library categories: $allowedLibraryCategories');
-    bool success = super.run(uri);
-    int cumulated = 0;
-    for (final task in tasks) {
-      cumulated += task.timing;
-      log('${task.name} took ${task.timing}msec');
-    }
-    int total = totalCompileTime.elapsedMilliseconds;
-    log('Total compile-time ${total}msec;'
-        ' unaccounted ${total - cumulated}msec');
-    return success;
+    return super.run(uri).then((bool success) {
+      int cumulated = 0;
+      for (final task in tasks) {
+        cumulated += task.timing;
+        log('${task.name} took ${task.timing}msec');
+      }
+      int total = totalCompileTime.elapsedMilliseconds;
+      log('Total compile-time ${total}msec;'
+          ' unaccounted ${total - cumulated}msec');
+      return success;
+    });
   }
 
   void reportDiagnostic(leg.SourceSpan span, String message,
diff --git a/sdk/lib/_internal/compiler/implementation/compiler.dart b/sdk/lib/_internal/compiler/implementation/compiler.dart
index 7e543d0ca65..158bb57edb1 100644
--- a/sdk/lib/_internal/compiler/implementation/compiler.dart
+++ b/sdk/lib/_internal/compiler/implementation/compiler.dart
@@ -36,7 +36,6 @@ abstract class WorkItem {
     assert(invariant(element, element.isDeclaration));
   }
 
-
   void run(Compiler compiler, Enqueuer world);
 }
 
@@ -81,11 +80,6 @@ class PostProcessTask {
   PostProcessTask(this.element, this.action);
 }
 
-class ReadingFilesTask extends CompilerTask {
-  ReadingFilesTask(Compiler compiler) : super(compiler);
-  String get name => 'Reading input files';
-}
-
 abstract class Backend {
   final Compiler compiler;
   final ConstantSystem constantSystem;
@@ -253,7 +247,9 @@ abstract class Backend {
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
-  void onLibraryLoaded(LibraryElement library, Uri uri) {}
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
+    return new Future.value();
+  }
 
   void registerMetadataInstantiatedType(DartType type, TreeElements elements) {}
   void registerMetadataStaticUse(Element element) {}
@@ -512,7 +508,6 @@ abstract class Compiler implements DiagnosticListener {
   ConstantHandler constantHandler;
   ConstantHandler metadataHandler;
   EnqueueTask enqueuer;
-  CompilerTask fileReadingTask;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   ContainerTracer containerTracer;
@@ -614,7 +609,6 @@ abstract class Compiler implements DiagnosticListener {
     validator = new TreeValidatorTask(this);
 
     tasks = [
-      fileReadingTask = new ReadingFilesTask(this),
       libraryLoader = new LibraryLoaderTask(this),
       scanner = new ScannerTask(this),
       dietParser = new DietParserTask(this),
@@ -731,14 +725,15 @@ abstract class Compiler implements DiagnosticListener {
     reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
-  bool run(Uri uri) {
+  Future<bool> run(Uri uri) {
     totalCompileTime.start();
-    try {
-      runCompiler(uri);
-    } on CompilerCancelledException catch (exception) {
-      log('Error: $exception');
-      return false;
-    } catch (exception) {
+
+    return new Future.sync(() => runCompiler(uri)).catchError((error) {
+      if (error is CompilerCancelledException) {
+        log('Error: $error');
+        return false;
+      }
+
       try {
         if (!hasCrashed) {
           hasCrashed = true;
@@ -750,12 +745,13 @@ abstract class Compiler implements DiagnosticListener {
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
-      rethrow;
-    } finally {
+      throw error;
+    }).whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
-    }
-    return !compilationFailed;
+    }).then((_) {
+      return !compilationFailed;
+    });
   }
 
   bool hasIsolateSupport() => isolateLibrary != null;
@@ -764,7 +760,7 @@ abstract class Compiler implements DiagnosticListener {
    * This method is called before [library] import and export scopes have been
    * set up.
    */
-  void onLibraryLoaded(LibraryElement library, Uri uri) {
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (dynamicClass != null) {
       // When loading the built-in libraries, dynamicClass is null. We
       // take advantage of this as core imports js_helper and sees [dynamic]
@@ -791,12 +787,12 @@ abstract class Compiler implements DiagnosticListener {
           findRequiredElement(library, const SourceString('DeferredLibrary'));
     } else if (isolateHelperLibrary == null
 	       && (uri == new Uri(scheme: 'dart', path: '_isolate_helper'))) {
-      isolateHelperLibrary = scanBuiltinLibrary('_isolate_helper');
+      isolateHelperLibrary = library;
     } else if (foreignLibrary == null
 	       && (uri == new Uri(scheme: 'dart', path: '_foreign_helper'))) {
-      foreignLibrary = scanBuiltinLibrary('_foreign_helper');
+      foreignLibrary = library;
     }
-    backend.onLibraryLoaded(library, uri);
+    return backend.onLibraryLoaded(library, uri);
   }
 
   Element findRequiredElement(LibraryElement library, SourceString name) {
@@ -824,7 +820,7 @@ abstract class Compiler implements DiagnosticListener {
     }
   }
 
-  LibraryElement scanBuiltinLibrary(String filename);
+  Future<LibraryElement> scanBuiltinLibrary(String filename);
 
   void initializeSpecialClasses() {
     final List missingCoreClasses = [];
@@ -902,26 +898,32 @@ abstract class Compiler implements DiagnosticListener {
         listClass.lookupConstructor(callConstructor);
   }
 
-  void scanBuiltinLibraries() {
-    jsHelperLibrary = scanBuiltinLibrary('_js_helper');
-    interceptorsLibrary = scanBuiltinLibrary('_interceptors');
-    assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
-    identicalFunction = coreLibrary.find(const SourceString('identical'));
+  Future scanBuiltinLibraries() {
+    return scanBuiltinLibrary('_js_helper').then((LibraryElement library) {
+      jsHelperLibrary = library;
+      return scanBuiltinLibrary('_interceptors');
+    }).then((LibraryElement library) {
+      interceptorsLibrary = library;
 
-    initializeSpecialClasses();
+      assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
+      identicalFunction = coreLibrary.find(const SourceString('identical'));
 
-    functionClass.ensureResolved(this);
-    functionApplyMethod =
-        functionClass.lookupLocalMember(const SourceString('apply'));
-    jsInvocationMirrorClass.ensureResolved(this);
-    invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
+      initializeSpecialClasses();
 
-    if (preserveComments) {
-      var uri = new Uri(scheme: 'dart', path: 'mirrors');
-      LibraryElement libraryElement =
-          libraryLoader.loadLibrary(uri, null, uri);
-      documentClass = libraryElement.find(const SourceString('Comment'));
-    }
+      functionClass.ensureResolved(this);
+      functionApplyMethod =
+          functionClass.lookupLocalMember(const SourceString('apply'));
+      jsInvocationMirrorClass.ensureResolved(this);
+      invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
+
+      if (preserveComments) {
+        var uri = new Uri(scheme: 'dart', path: 'mirrors');
+        return libraryLoader.loadLibrary(uri, null, uri).then(
+            (LibraryElement libraryElement) {
+          documentClass = libraryElement.find(const SourceString('Comment'));
+        });
+      }
+    });
   }
 
   void importHelperLibrary(LibraryElement library) {
@@ -936,28 +938,39 @@ abstract class Compiler implements DiagnosticListener {
    */
   Uri resolvePatchUri(String dartLibraryPath);
 
-  void runCompiler(Uri uri) {
+  Future runCompiler(Uri uri) {
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times.  Implement a better mechanism where StringWrapper
     // instances are shared on a per library basis.
     SourceString.canonicalizedValues.clear();
 
     assert(uri != null || analyzeOnly);
-    scanBuiltinLibraries();
-    if (librariesToAnalyzeWhenRun != null) {
-      for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-        log('analyzing $libraryUri ($buildId)');
-        libraryLoader.loadLibrary(libraryUri, null, libraryUri);
+    return scanBuiltinLibraries().then((_) {
+      if (librariesToAnalyzeWhenRun != null) {
+        return Future.forEach(librariesToAnalyzeWhenRun, (libraryUri) {
+          log('analyzing $libraryUri ($buildId)');
+          return libraryLoader.loadLibrary(libraryUri, null, libraryUri);
+        });
       }
-    }
-    if (uri != null) {
-      if (analyzeOnly) {
-        log('analyzing $uri ($buildId)');
-      } else {
-        log('compiling $uri ($buildId)');
+    }).then((_) {
+      if (uri != null) {
+        if (analyzeOnly) {
+          log('analyzing $uri ($buildId)');
+        } else {
+          log('compiling $uri ($buildId)');
+        }
+        return libraryLoader.loadLibrary(uri, null, uri)
+            .then((LibraryElement library) {
+          mainApp = library;
+        });
       }
-      mainApp = libraryLoader.loadLibrary(uri, null, uri);
-    }
+    }).then((_) {
+      compileLoadedLibraries();
+    });
+  }
+
+  /// Performs the compilation when all libraries have been loaded.
+  void compileLoadedLibraries() {
     Element main = null;
     if (mainApp != null) {
       main = mainApp.find(MAIN);
@@ -973,8 +986,8 @@ abstract class Compiler implements DiagnosticListener {
               mainApp,
               MessageKind.GENERIC,
               {'text': 'Error: Could not find "${MAIN.slowToString()}". '
-                  'No source will be analyzed. '
-                  'Use "--analyze-all" to analyze all code in the library.'});
+              'No source will be analyzed. '
+              'Use "--analyze-all" to analyze all code in the library.'});
         }
       } else {
         if (!main.isFunction()) {
@@ -990,7 +1003,7 @@ abstract class Compiler implements DiagnosticListener {
               parameter,
               MessageKind.GENERIC,
               {'text':
-                  'Error: "${MAIN.slowToString()}" cannot have parameters.'});
+                'Error: "${MAIN.slowToString()}" cannot have parameters.'});
         });
       }
 
@@ -1046,7 +1059,8 @@ abstract class Compiler implements DiagnosticListener {
       backend.enableNoSuchMethod(enqueuer.codegen);
     }
     if (compileAll) {
-      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib, enqueuer.codegen));
+      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib,
+          enqueuer.codegen));
     }
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
@@ -1373,7 +1387,7 @@ abstract class Compiler implements DiagnosticListener {
    *
    * See [LibraryLoader] for terminology on URIs.
    */
-  Script readScript(Uri readableUri, [Node node]) {
+  Future<Script> readScript(Uri readableUri, [Element element, Node node]) {
     unimplemented('Compiler.readScript');
   }
 
@@ -1517,10 +1531,14 @@ class SourceSpan {
 bool invariant(Spannable spannable, var condition, {var message: null}) {
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
+  if (spannable == null) {
+    throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
+        "Spannable was null for invariant. Use CURRENT_ELEMENT_SPANNABLE.");
+  }
   if (condition is Function){
     condition = condition();
   }
-  if (spannable == null || !condition) {
+  if (!condition) {
     if (message is Function) {
       message = message();
     }
diff --git a/sdk/lib/_internal/compiler/implementation/dart2js.dart b/sdk/lib/_internal/compiler/implementation/dart2js.dart
index 6b24057072b..d4dfd776366 100644
--- a/sdk/lib/_internal/compiler/implementation/dart2js.dart
+++ b/sdk/lib/_internal/compiler/implementation/dart2js.dart
@@ -91,7 +91,7 @@ void parseCommandLine(List<OptionHandler> handlers, List<String> argv) {
   }
 }
 
-void compile(List<String> argv) {
+Future compile(List<String> argv) {
   bool isWindows = (Platform.operatingSystem == 'windows');
   stackTraceFilePrefix = '$currentDirectory';
   Uri libraryRoot = currentDirectory;
@@ -105,6 +105,7 @@ void compile(List<String> argv) {
   String outputLanguage = 'JavaScript';
   bool stripArgumentSet = false;
   bool analyzeOnly = false;
+  // TODO(johnniwinther): Measure time for reading files.
   SourceFileProvider inputProvider = new SourceFileProvider();
   FormattingDiagnosticHandler diagnosticHandler =
       new FormattingDiagnosticHandler(inputProvider);
@@ -287,11 +288,6 @@ void compile(List<String> argv) {
     helpAndFail('Error: Extra arguments: ${extra.join(" ")}');
   }
 
-  void handler(Uri uri, int begin, int end, String message,
-               api.Diagnostic kind) {
-    diagnosticHandler.diagnosticHandler(uri, begin, end, message, kind);
-  }
-
   Uri uri = currentDirectory.resolve(arguments[0]);
   if (packageRoot == null) {
     packageRoot = uri.resolve('./packages/');
@@ -386,10 +382,10 @@ void compile(List<String> argv) {
     return new EventSinkWrapper(writeStringSync, onDone);
   }
 
-  api.compile(uri, libraryRoot, packageRoot,
-              inputProvider.readStringFromUri, handler,
+  return api.compile(uri, libraryRoot, packageRoot,
+              inputProvider, diagnosticHandler,
               options, outputProvider)
-      .then(compilationDone);
+            .then(compilationDone);
 }
 
 class EventSinkWrapper extends EventSink<String> {
@@ -424,11 +420,11 @@ void fail(String message) {
   exit(1);
 }
 
-void compilerMain(Options options) {
+Future compilerMain(Options options) {
   var root = uriPathToNative("/$LIBRARY_ROOT");
   List<String> argv = ['--library-root=${options.script}$root'];
   argv.addAll(options.arguments);
-  compile(argv);
+  return compile(argv);
 }
 
 void help() {
@@ -566,20 +562,22 @@ void helpAndFail(String message) {
 }
 
 void mainWithErrorHandler(Options options) {
-  try {
-    compilerMain(options);
-  } catch (exception, trace) {
+  new Future.sync(() => compilerMain(options)).catchError((exception) {
     try {
       print('Internal error: $exception');
     } catch (ignored) {
       print('Internal error: error while printing exception');
     }
+
     try {
-      print(trace);
+      var trace = getAttachedStackTrace(exception);
+      if (trace != null) {
+        print(trace);
+      }
     } finally {
       exit(253); // 253 is recognized as a crash by our test scripts.
     }
-  }
+  });
 }
 
 void main() {
diff --git a/sdk/lib/_internal/compiler/implementation/dart_backend/backend.dart b/sdk/lib/_internal/compiler/implementation/dart_backend/backend.dart
index aaab842dba5..13a215950f4 100644
--- a/sdk/lib/_internal/compiler/implementation/dart_backend/backend.dart
+++ b/sdk/lib/_internal/compiler/implementation/dart_backend/backend.dart
@@ -505,15 +505,19 @@ class DartBackend extends Backend {
 
   log(String message) => compiler.log('[DartBackend] $message');
 
-  void onLibraryLoaded(LibraryElement library, Uri uri) {
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (useMirrorHelperLibrary && library == compiler.mirrorsLibrary) {
-      mirrorHelperLibrary = compiler.scanBuiltinLibrary(
-          MirrorRenamer.MIRROR_HELPER_LIBRARY_NAME);
-      mirrorHelperGetNameFunction = mirrorHelperLibrary.find(
-          const SourceString(MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION));
-      mirrorHelperSymbolsMap = mirrorHelperLibrary.find(
-          const SourceString(MirrorRenamer.MIRROR_HELPER_SYMBOLS_MAP_NAME));
+      return compiler.scanBuiltinLibrary(
+          MirrorRenamer.MIRROR_HELPER_LIBRARY_NAME).
+          then((LibraryElement element) {
+        mirrorHelperLibrary = element;
+        mirrorHelperGetNameFunction = mirrorHelperLibrary.find(
+            const SourceString(MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION));
+        mirrorHelperSymbolsMap = mirrorHelperLibrary.find(
+            const SourceString(MirrorRenamer.MIRROR_HELPER_SYMBOLS_MAP_NAME));
+      });
     }
+    return new Future.value();
   }
 
   void registerStaticSend(Element element, Node node) {
diff --git a/sdk/lib/_internal/compiler/implementation/dart_backend/dart_backend.dart b/sdk/lib/_internal/compiler/implementation/dart_backend/dart_backend.dart
index 29d4b4dc396..a4410d48dc1 100644
--- a/sdk/lib/_internal/compiler/implementation/dart_backend/dart_backend.dart
+++ b/sdk/lib/_internal/compiler/implementation/dart_backend/dart_backend.dart
@@ -4,6 +4,7 @@
 
 library dart_backend;
 
+import 'dart:async' show Future;
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show SynthesizedConstructorElementX;
 import '../dart2jslib.dart';
diff --git a/sdk/lib/_internal/compiler/implementation/deferred_load.dart b/sdk/lib/_internal/compiler/implementation/deferred_load.dart
index 4ecf03f6340..bba00f606a7 100644
--- a/sdk/lib/_internal/compiler/implementation/deferred_load.dart
+++ b/sdk/lib/_internal/compiler/implementation/deferred_load.dart
@@ -47,8 +47,6 @@ class DeferredLoadTask extends CompilerTask {
   /// should become obsolete.
   final Set<Element> allDeferredElements = new LinkedHashSet<Element>();
 
-  ClassElement cachedDeferredLibraryClass;
-
   DeferredLoadTask(Compiler compiler) : super(compiler);
 
   String get name => 'Deferred Loading';
diff --git a/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart b/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
index e918fc4e5dc..08c0e307209 100644
--- a/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
+++ b/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
@@ -1490,7 +1490,7 @@ class JavaScriptBackend extends Backend {
     return false;
   }
 
-  void onLibraryLoaded(LibraryElement library, Uri uri) {
+  Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (uri == Uri.parse('dart:_js_mirrors')) {
       disableTreeShakingMarker =
           library.find(const SourceString('disableTreeShaking'));
@@ -1500,6 +1500,7 @@ class JavaScriptBackend extends Backend {
       preserveNamesMarker =
           library.find(const SourceString('preserveNames'));
     }
+    return new Future.value();
   }
 
   void registerMetadataInstantiatedType(DartType type, TreeElements elements) {
diff --git a/sdk/lib/_internal/compiler/implementation/js_backend/js_backend.dart b/sdk/lib/_internal/compiler/implementation/js_backend/js_backend.dart
index 4f7b4998cac..2d9888b59da 100644
--- a/sdk/lib/_internal/compiler/implementation/js_backend/js_backend.dart
+++ b/sdk/lib/_internal/compiler/implementation/js_backend/js_backend.dart
@@ -4,6 +4,7 @@
 
 library js_backend;
 
+import 'dart:async' show Future;
 import 'dart:collection' show LinkedHashMap, Queue;
 
 import '../closure.dart';
diff --git a/sdk/lib/_internal/compiler/implementation/library_loader.dart b/sdk/lib/_internal/compiler/implementation/library_loader.dart
index 55031d27330..3c515a18c27 100644
--- a/sdk/lib/_internal/compiler/implementation/library_loader.dart
+++ b/sdk/lib/_internal/compiler/implementation/library_loader.dart
@@ -113,12 +113,13 @@ abstract class LibraryLoader extends CompilerTask {
    */
   // TODO(johnniwinther): Remove [canonicalUri] together with
   // [Compiler.scanBuiltinLibrary].
-  LibraryElement loadLibrary(Uri resolvedUri, Node node, Uri canonicalUri);
+  Future<LibraryElement> loadLibrary(Uri resolvedUri, Node node,
+                                     Uri canonicalUri);
 
   // TODO(johnniwinther): Remove this when patches don't need special parsing.
-  void registerLibraryFromTag(LibraryDependencyHandler handler,
-                              LibraryElement library,
-                              LibraryDependency tag);
+  Future registerLibraryFromTag(LibraryDependencyHandler handler,
+                                LibraryElement library,
+                                LibraryDependency tag);
 
   /**
    * Adds the elements in the export scope of [importedLibrary] to the import
@@ -227,18 +228,25 @@ class LibraryLoaderTask extends LibraryLoader {
 
   LibraryDependencyHandler currentHandler;
 
-  LibraryElement loadLibrary(Uri resolvedUri, Node node, Uri canonicalUri) {
+  Future<LibraryElement> loadLibrary(Uri resolvedUri, Node node,
+      Uri canonicalUri) {
     return measure(() {
       assert(currentHandler == null);
+      // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
+      // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(compiler);
-      LibraryElement library =
-          createLibrary(currentHandler, null, resolvedUri, node, canonicalUri);
-      currentHandler.computeExports();
-      currentHandler = null;
-      var workList = onLibraryLoadedCallbacks;
-      onLibraryLoadedCallbacks = [];
-      workList.forEach((f) => f());
-      return library;
+      return createLibrary(currentHandler, null, resolvedUri, node,
+          canonicalUri).then((LibraryElement library) {
+        return compiler.withCurrentElement(library, () {
+          return measure(() {
+            currentHandler.computeExports();
+            currentHandler = null;
+            var workList = onLibraryLoadedCallbacks;
+            onLibraryLoadedCallbacks = [];
+            return Future.forEach(workList, (f) => f()).then((_) => library);
+          });
+        });
+      });
     });
   }
 
@@ -248,8 +256,8 @@ class LibraryLoaderTask extends LibraryLoader {
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
    */
-  void processLibraryTags(LibraryDependencyHandler handler,
-                          LibraryElement library) {
+  Future processLibraryTags(LibraryDependencyHandler handler,
+                            LibraryElement library) {
     int tagState = TagState.NO_TAG_SEEN;
 
     /**
@@ -270,49 +278,62 @@ class LibraryLoaderTask extends LibraryLoader {
     bool importsDartCore = false;
     var libraryDependencies = new LinkBuilder<LibraryDependency>();
     Uri base = library.entryCompilationUnit.script.uri;
-    for (LibraryTag tag in library.tags.reverse()) {
-      if (tag.isImport) {
-        Import import = tag;
-        tagState = checkTag(TagState.IMPORT_OR_EXPORT, import);
-        if (import.uri.dartString.slowToString() == 'dart:core') {
-          importsDartCore = true;
-        }
-        libraryDependencies.addLast(import);
-      } else if (tag.isExport) {
-        tagState = checkTag(TagState.IMPORT_OR_EXPORT, tag);
-        libraryDependencies.addLast(tag);
-      } else if (tag.isLibraryName) {
-        tagState = checkTag(TagState.LIBRARY, tag);
-        if (library.libraryTag != null) {
-          compiler.cancel("duplicated library declaration", node: tag);
+
+    // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
+    return Future.forEach(library.tags.reverse().toList(), (LibraryTag tag) {
+      compiler.withCurrentElement(library, () {
+        if (tag.isImport) {
+          Import import = tag;
+          tagState = checkTag(TagState.IMPORT_OR_EXPORT, import);
+          if (import.uri.dartString.slowToString() == 'dart:core') {
+            importsDartCore = true;
+          }
+          libraryDependencies.addLast(import);
+        } else if (tag.isExport) {
+          tagState = checkTag(TagState.IMPORT_OR_EXPORT, tag);
+          libraryDependencies.addLast(tag);
+        } else if (tag.isLibraryName) {
+          tagState = checkTag(TagState.LIBRARY, tag);
+          if (library.libraryTag != null) {
+            compiler.cancel("duplicated library declaration", node: tag);
+          } else {
+            library.libraryTag = tag;
+          }
+          checkDuplicatedLibraryName(library);
+        } else if (tag.isPart) {
+          Part part = tag;
+          StringNode uri = part.uri;
+          Uri resolvedUri = base.resolve(uri.dartString.slowToString());
+          tagState = checkTag(TagState.SOURCE, part);
+          return scanPart(part, resolvedUri, library);
         } else {
-          library.libraryTag = tag;
+          compiler.internalError("Unhandled library tag.", node: tag);
         }
-        checkDuplicatedLibraryName(library);
-      } else if (tag.isPart) {
-        Part part = tag;
-        StringNode uri = part.uri;
-        Uri resolvedUri = base.resolve(uri.dartString.slowToString());
-        tagState = checkTag(TagState.SOURCE, part);
-        scanPart(part, resolvedUri, library);
-      } else {
-        compiler.internalError("Unhandled library tag.", node: tag);
-      }
-    }
-
-    // Apply patch, if any.
-    if (library.isPlatformLibrary) {
-      patchDartLibrary(handler, library, library.canonicalUri.path);
-    }
-
-    // Import dart:core if not already imported.
-    if (!importsDartCore && !isDartCore(library.canonicalUri)) {
-      handler.registerDependency(library, null, loadCoreLibrary(handler));
-    }
-
-    for (LibraryDependency tag in libraryDependencies.toLink()) {
-      registerLibraryFromTag(handler, library, tag);
-    }
+      });
+    }).then((_) {
+      return compiler.withCurrentElement(library, () {
+        // Apply patch, if any.
+        if (library.isPlatformLibrary) {
+          return patchDartLibrary(handler, library, library.canonicalUri.path);
+        }
+      });
+    }).then((_) {
+      return compiler.withCurrentElement(library, () {
+        // Import dart:core if not already imported.
+        if (!importsDartCore && !isDartCore(library.canonicalUri)) {
+          return loadCoreLibrary(handler).then((LibraryElement coreLibrary) {
+            handler.registerDependency(library, null, coreLibrary);
+          });
+        }
+      });
+    }).then((_) {
+      // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
+      return Future.forEach(libraryDependencies.toLink().toList(), (tag) {
+        return compiler.withCurrentElement(library, () {
+          return registerLibraryFromTag(handler, library, tag);
+        });
+      });
+    });
   }
 
   void checkDuplicatedLibraryName(LibraryElement library) {
@@ -341,42 +362,48 @@ class LibraryLoaderTask extends LibraryLoader {
   /**
    * Lazily loads and returns the [LibraryElement] for the dart:core library.
    */
-  LibraryElement loadCoreLibrary(LibraryDependencyHandler handler) {
-    if (compiler.coreLibrary == null) {
-      Uri coreUri = new Uri(scheme: 'dart', path: 'core');
-      compiler.coreLibrary
-          = createLibrary(handler, null, coreUri, null, coreUri);
+  Future<LibraryElement> loadCoreLibrary(LibraryDependencyHandler handler) {
+    if (compiler.coreLibrary != null) {
+      return new Future.value(compiler.coreLibrary);
     }
-    return compiler.coreLibrary;
+
+    Uri coreUri = new Uri(scheme: 'dart', path: 'core');
+    return createLibrary(handler, null, coreUri, null, coreUri)
+        .then((LibraryElement library) {
+      compiler.coreLibrary = library;
+      return library;
+    });
   }
 
-  void patchDartLibrary(LibraryDependencyHandler handler,
+  Future patchDartLibrary(LibraryDependencyHandler handler,
                         LibraryElement library, String dartLibraryPath) {
-    if (library.isPatched) return;
+    if (library.isPatched) return new Future.value();
     Uri patchUri = compiler.resolvePatchUri(dartLibraryPath);
-    if (patchUri != null) {
-      compiler.patchParser.patchLibrary(handler, patchUri, library);
-    }
+    if (patchUri == null) return new Future.value();
+
+    return compiler.patchParser.patchLibrary(handler, patchUri, library);
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
-  void scanPart(Part part, Uri resolvedUri, LibraryElement library) {
+  Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
-    if (readableUri == null) return;
-    Script sourceScript = compiler.readScript(readableUri, part);
-    if (sourceScript == null) return;
-    CompilationUnitElement unit =
-        new CompilationUnitElementX(sourceScript, library);
-    compiler.withCurrentElement(unit, () {
-      compiler.scanner.scan(unit);
-      if (unit.partTag == null) {
-        compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
-      }
-    });
+    if (readableUri == null) return new Future.value();
+    return compiler.readScript(readableUri, library, part).
+        then((Script sourceScript) {
+          if (sourceScript == null) return;
+          CompilationUnitElement unit =
+              new CompilationUnitElementX(sourceScript, library);
+          compiler.withCurrentElement(unit, () {
+            compiler.scanner.scan(unit);
+            if (unit.partTag == null) {
+              compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
+            }
+          });
+        });
   }
 
   /**
@@ -384,25 +411,27 @@ class LibraryLoaderTask extends LibraryLoader {
    * registering its dependency in [handler] for the computation of the import/
    * export scope.
    */
-  void registerLibraryFromTag(LibraryDependencyHandler handler,
-                              LibraryElement library,
-                              LibraryDependency tag) {
+  Future registerLibraryFromTag(LibraryDependencyHandler handler,
+                                LibraryElement library,
+                                LibraryDependency tag) {
     Uri base = library.entryCompilationUnit.script.uri;
     Uri resolvedUri = base.resolve(tag.uri.dartString.slowToString());
-    LibraryElement loadedLibrary =
-        createLibrary(handler, library, resolvedUri, tag.uri, resolvedUri);
-    if (loadedLibrary == null) return;
-    handler.registerDependency(library, tag, loadedLibrary);
+    return createLibrary(handler, library, resolvedUri, tag.uri, resolvedUri)
+        .then((LibraryElement loadedLibrary) {
+          if (loadedLibrary == null) return;
+          compiler.withCurrentElement(library, () {
+            handler.registerDependency(library, tag, loadedLibrary);
 
-    if (!loadedLibrary.hasLibraryName()) {
-      compiler.withCurrentElement(library, () {
-        compiler.reportFatalError(
-            tag == null ? null : tag.uri,
-            MessageKind.GENERIC,
-            {'text':
-             'Error: No library name found in ${loadedLibrary.canonicalUri}.'});
-      });
-    }
+            if (!loadedLibrary.hasLibraryName()) {
+              compiler.reportFatalError(
+                  tag == null ? null : tag.uri,
+                  MessageKind.GENERIC,
+                  {'text':
+                   'Error: No library name found in '
+                      '${loadedLibrary.canonicalUri}.'});
+            }
+          });
+        });
   }
 
   /**
@@ -413,38 +442,42 @@ class LibraryLoaderTask extends LibraryLoader {
    */
   // TODO(johnniwinther): Remove [canonicalUri] and make [resolvedUri] the
   // canonical uri when [Compiler.scanBuiltinLibrary] is removed.
-  LibraryElement createLibrary(LibraryDependencyHandler handler,
+  Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
                                LibraryElement importingLibrary,
                                Uri resolvedUri, Node node, Uri canonicalUri) {
     // TODO(johnniwinther): Create erroneous library elements for missing
     // libraries.
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
-    if (readableUri == null) return null;
+    if (readableUri == null) return new Future.value();
     LibraryElement library;
     if (canonicalUri != null) {
       library = compiler.libraries[canonicalUri.toString()];
     }
-    if (library == null) {
-      Script script = compiler.readScript(readableUri, node);
-      if (script == null) return null;
-
-      library = new LibraryElementX(script, canonicalUri);
-      handler.registerNewLibrary(library);
-      native.maybeEnableNative(compiler, library);
-      if (canonicalUri != null) {
-        compiler.libraries[canonicalUri.toString()] = library;
-      }
-      
-      compiler.withCurrentElement(library, () {
-        compiler.scanner.scanLibrary(library);
-        processLibraryTags(handler, library);
-        handler.registerLibraryExports(library);
-        onLibraryLoadedCallbacks.add(
-            () => compiler.onLibraryLoaded(library, resolvedUri));
-      });
+    if (library != null) {
+      return new Future.value(library);
     }
-    return library;
+    return compiler.readScript(readableUri, importingLibrary, node)
+        .then((Script script) {
+          if (script == null) return null;
+          LibraryElement element = new LibraryElementX(script, canonicalUri);
+          compiler.withCurrentElement(element, () {
+            handler.registerNewLibrary(element);
+            native.maybeEnableNative(compiler, element);
+            if (canonicalUri != null) {
+              compiler.libraries[canonicalUri.toString()] = element;
+            }
+            compiler.scanner.scanLibrary(element);
+          });
+          return processLibraryTags(handler, element).then((_) {
+            compiler.withCurrentElement(element, () {
+              handler.registerLibraryExports(element);
+              onLibraryLoadedCallbacks.add(
+                  () => compiler.onLibraryLoaded(element, resolvedUri));
+            });
+            return element;
+          });
+        });
   }
 
   // TODO(johnniwinther): Remove this method when 'js_helper' is handled by
diff --git a/sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart b/sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart
index 74b6e563cec..54317535b43 100644
--- a/sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart
+++ b/sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart
@@ -227,12 +227,13 @@ Future<MirrorSystem> analyze(List<Uri> libraries,
                                            internalDiagnosticHandler,
                                            libraryRoot, packageRoot, options);
   compiler.librariesToAnalyzeWhenRun = libraries;
-  bool success = compiler.run(null);
-  if (success && !compilationFailed) {
-    return new Future<MirrorSystem>.value(new Dart2JsMirrorSystem(compiler));
-  } else {
-    return new Future<MirrorSystem>.error('Failed to create mirror system.');
-  }
+  return compiler.run(null).then((bool success) {
+    if (success && !compilationFailed) {
+      return new Dart2JsMirrorSystem(compiler);
+    } else {
+      throw new StateError('Failed to create mirror system.');
+    }
+  });
 }
 
 //------------------------------------------------------------------------------
@@ -382,7 +383,7 @@ abstract class Dart2JsElementMirror extends Dart2JsDeclarationMirror {
       // Lookup [: prefix.id :].
       String prefix = name.substring(0, index);
       String id = name.substring(index+1);
-      result = scope.lookup(new SourceString(prefix)); 
+      result = scope.lookup(new SourceString(prefix));
       if (result != null && result.isPrefix()) {
         PrefixElement prefix = result;
         result = prefix.lookupLocalMember(new SourceString(id));
diff --git a/sdk/lib/_internal/compiler/implementation/patch_parser.dart b/sdk/lib/_internal/compiler/implementation/patch_parser.dart
index d21e842a6a2..42d036f1be7 100644
--- a/sdk/lib/_internal/compiler/implementation/patch_parser.dart
+++ b/sdk/lib/_internal/compiler/implementation/patch_parser.dart
@@ -114,6 +114,8 @@
 
 library patchparser;
 
+import 'dart:async';
+
 import "tree/tree.dart" as tree;
 import "dart2jslib.dart" as leg;  // CompilerTask, Compiler.
 import "../compiler.dart" as api;
@@ -131,28 +133,31 @@ class PatchParserTask extends leg.CompilerTask {
    * injections to the library, and returns a list of class
    * patches.
    */
-  void patchLibrary(leg.LibraryDependencyHandler handler,
+  Future patchLibrary(leg.LibraryDependencyHandler handler,
                     Uri patchUri, LibraryElement originLibrary) {
-
-    leg.Script script = compiler.readScript(patchUri, null);
-    var patchLibrary = new LibraryElementX(script, null, originLibrary);
-    compiler.withCurrentElement(patchLibrary, () {
-      handler.registerNewLibrary(patchLibrary);
-      LinkBuilder<tree.LibraryTag> imports = new LinkBuilder<tree.LibraryTag>();
-      compiler.withCurrentElement(patchLibrary.entryCompilationUnit, () {
-        // This patches the elements of the patch library into [library].
-        // Injected elements are added directly under the compilation unit.
-        // Patch elements are stored on the patched functions or classes.
-        scanLibraryElements(patchLibrary.entryCompilationUnit, imports);
+    return compiler.readScript(patchUri, null).then((leg.Script script) {
+      var patchLibrary = new LibraryElementX(script, null, originLibrary);
+      return compiler.withCurrentElement(patchLibrary, () {
+        handler.registerNewLibrary(patchLibrary);
+        var imports = new LinkBuilder<tree.LibraryTag>();
+        compiler.withCurrentElement(patchLibrary.entryCompilationUnit, () {
+          // This patches the elements of the patch library into [library].
+          // Injected elements are added directly under the compilation unit.
+          // Patch elements are stored on the patched functions or classes.
+          scanLibraryElements(patchLibrary.entryCompilationUnit, imports);
+        });
+        // After scanning declarations, we handle the import tags in the patch.
+        // TODO(lrn): These imports end up in the original library and are in
+        // scope for the original methods too. This should be fixed.
+        compiler.importHelperLibrary(originLibrary);
+        // TODO(rnystrom): Remove .toList() here if #11523 is fixed.
+        return Future.forEach(imports.toLink().toList(), (tag) {
+          return compiler.withCurrentElement(patchLibrary, () {
+            return compiler.libraryLoader.registerLibraryFromTag(
+                handler, patchLibrary, tag);
+          });
+        });
       });
-      // After scanning declarations, we handle the import tags in the patch.
-      // TODO(lrn): These imports end up in the original library and are in
-      // scope for the original methods too. This should be fixed.
-      compiler.importHelperLibrary(originLibrary);
-      for (tree.LibraryTag tag in imports.toLink()) {
-        compiler.libraryLoader.registerLibraryFromTag(
-            handler, patchLibrary, tag);
-      }
     });
   }
 
diff --git a/sdk/lib/_internal/compiler/implementation/source_file_provider.dart b/sdk/lib/_internal/compiler/implementation/source_file_provider.dart
index ca48fda6604..352f03cea24 100644
--- a/sdk/lib/_internal/compiler/implementation/source_file_provider.dart
+++ b/sdk/lib/_internal/compiler/implementation/source_file_provider.dart
@@ -38,8 +38,9 @@ class SourceFileProvider {
     try {
       source = readAll(uriPathToNative(resourceUri.path));
     } on FileException catch (ex) {
-      throw "Error reading '${relativize(cwd, resourceUri, isWindows)}' "
-            "(${ex.osError})";
+      return new Future.error(
+          "Error reading '${relativize(cwd, resourceUri, isWindows)}' "
+          "(${ex.osError})");
     }
     dartCharactersRead += source.length;
     sourceFiles[resourceUri.toString()] = new SourceFile(
diff --git a/sdk/lib/_internal/compiler/implementation/util/util.dart b/sdk/lib/_internal/compiler/implementation/util/util.dart
index 3e60f245870..2638fd84173 100644
--- a/sdk/lib/_internal/compiler/implementation/util/util.dart
+++ b/sdk/lib/_internal/compiler/implementation/util/util.dart
@@ -35,7 +35,7 @@ class SpannableAssertionFailure {
   final String message;
   SpannableAssertionFailure(this.node, this.message);
 
-  String toString() => 'Compiler crashed: $message.';
+  String toString() => 'Compiler crashed: $message';
 }
 
 /**
diff --git a/sdk/lib/_internal/compiler/samples/leap/leap_leg.dart b/sdk/lib/_internal/compiler/samples/leap/leap_leg.dart
index 137c236e0a0..87ba938aa88 100644
--- a/sdk/lib/_internal/compiler/samples/leap/leap_leg.dart
+++ b/sdk/lib/_internal/compiler/samples/leap/leap_leg.dart
@@ -125,6 +125,8 @@ class Runner {
 
   String init() {
     Stopwatch sw = new Stopwatch()..start();
+    // TODO(rnystrom): This is broken now that scanBuiltInLibraries is async.
+    // Delete this sample.
     compiler.scanBuiltinLibraries();
     sw.stop();
     return 'Scanned core libraries in ${sw.elapsedMilliseconds}ms';
@@ -221,10 +223,14 @@ class LeapCompiler extends Compiler {
 
   String get legDirectory => libDir;
 
+  // TODO(rnystrom): This is broken now that scanBuiltInLibraries is async.
+  // Delete this sample.
   LibraryElement scanBuiltinLibrary(String path) {
     Uri base = Uri.parse(html.window.location.toString());
     Uri libraryRoot = base.resolve(libDir);
     Uri resolved = libraryRoot.resolve(DART2JS_LIBRARY_MAP[path]);
+    // TODO(rnystrom): This is broken now that scanBuiltInLibraries is async.
+    // Delete this sample.
     LibraryElement library = scanner.loadLibrary(resolved, null);
     return library;
   }
@@ -237,6 +243,8 @@ class LeapCompiler extends Compiler {
     return compilationUnit.script;
   }
 
+  // TODO(rnystrom): This is broken now that scanBuiltInLibraries is async.
+  // Delete this sample.
   Script readScript(Uri uri, [ScriptTag node]) {
     String text = "";
     try {
diff --git a/tests/compiler/dart2js/analyze_all_test.dart b/tests/compiler/dart2js/analyze_all_test.dart
index 2a7fcc70127..58a313c50b6 100644
--- a/tests/compiler/dart2js/analyze_all_test.dart
+++ b/tests/compiler/dart2js/analyze_all_test.dart
@@ -3,7 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
-import 'compiler_helper.dart';
+import "compiler_helper.dart";
+import "package:async_helper/async_helper.dart";
 
 const String SOURCE = """
 class Foo {
@@ -28,24 +29,29 @@ main() {
 
 main() {
   Uri uri = Uri.parse('test:code');
-  var compiler = compilerFor(SOURCE, uri, analyzeAll: false);
-  compiler.runCompiler(uri);
-  Expect.isFalse(compiler.compilationFailed);
-  print(compiler.warnings);
-  Expect.isTrue(compiler.warnings.isEmpty, 'unexpected warnings');
-  Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
-  compiler = compilerFor(SOURCE, uri, analyzeAll: true);
-  compiler.runCompiler(uri);
-  Expect.isTrue(compiler.compilationFailed);
-  Expect.isTrue(compiler.warnings.isEmpty, 'unexpected warnings');
-  Expect.equals(2, compiler.errors.length,
-                'expected exactly two errors, but got ${compiler.errors}');
+  asyncStart();
+  var compiler1 = compilerFor(SOURCE, uri, analyzeAll: false);
+  compiler1.runCompiler(uri).then((_) {
+    Expect.isFalse(compiler1.compilationFailed);
+    print(compiler1.warnings);
+    Expect.isTrue(compiler1.warnings.isEmpty, 'unexpected warnings');
+    Expect.isTrue(compiler1.errors.isEmpty, 'unexpected errors');
+  }).whenComplete(() => asyncEnd());
 
-  Expect.equals(MessageKind.CONSTRUCTOR_IS_NOT_CONST,
-                compiler.errors[0].message.kind);
-  Expect.equals("Foo", compiler.errors[0].node.toString());
+  asyncStart();
+  var compiler2 = compilerFor(SOURCE, uri, analyzeAll: true);
+  compiler2.runCompiler(uri).then((_) {
+    Expect.isTrue(compiler2.compilationFailed);
+    Expect.isTrue(compiler2.warnings.isEmpty, 'unexpected warnings');
+    Expect.equals(2, compiler2.errors.length,
+                  'expected exactly two errors, but got ${compiler2.errors}');
 
-  Expect.equals(MessageKind.CONSTRUCTOR_IS_NOT_CONST,
-                compiler.errors[1].message.kind);
-  Expect.equals("Foo", compiler.errors[1].node.toString());
+    Expect.equals(MessageKind.CONSTRUCTOR_IS_NOT_CONST,
+                  compiler2.errors[0].message.kind);
+    Expect.equals("Foo", compiler2.errors[0].node.toString());
+
+    Expect.equals(MessageKind.CONSTRUCTOR_IS_NOT_CONST,
+                  compiler2.errors[1].message.kind);
+    Expect.equals("Foo", compiler2.errors[1].node.toString());
+  }).whenComplete(() => asyncEnd());
 }
diff --git a/tests/compiler/dart2js/analyze_api_test.dart b/tests/compiler/dart2js/analyze_api_test.dart
index ec291dd622a..de48a2ec6e6 100644
--- a/tests/compiler/dart2js/analyze_api_test.dart
+++ b/tests/compiler/dart2js/analyze_api_test.dart
@@ -6,6 +6,7 @@ library analyze_api;
 
 import '../../../sdk/lib/_internal/libraries.dart';
 import 'analyze_helper.dart';
+import "package:async_helper/async_helper.dart";
 
 /**
  * Map of white-listed warnings and errors.
@@ -28,5 +29,5 @@ void main() {
       uriList.add(new Uri(scheme: 'dart', path: name));
     }
   });
-  analyze(uriList, WHITE_LIST);
+  asyncTest(() => analyze(uriList, WHITE_LIST));
 }
diff --git a/tests/compiler/dart2js/analyze_dart2js_test.dart b/tests/compiler/dart2js/analyze_dart2js_test.dart
index 8f2a6419de7..95080833446 100644
--- a/tests/compiler/dart2js/analyze_dart2js_test.dart
+++ b/tests/compiler/dart2js/analyze_dart2js_test.dart
@@ -7,6 +7,7 @@ library analyze_api;
 import "package:expect/expect.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/filenames.dart';
 import 'analyze_helper.dart';
+import "package:async_helper/async_helper.dart";
 
 /**
  * Map of whitelisted warnings and errors.
@@ -25,5 +26,5 @@ const Map<String,List<String>> WHITE_LIST = const {
 void main() {
   var uri = currentDirectory.resolve(
       'sdk/lib/_internal/compiler/implementation/dart2js.dart');
-  analyze([uri], WHITE_LIST);
+  asyncTest(() => analyze([uri], WHITE_LIST));
 }
diff --git a/tests/compiler/dart2js/analyze_helper.dart b/tests/compiler/dart2js/analyze_helper.dart
index a9c081df39e..3eee5f88195 100644
--- a/tests/compiler/dart2js/analyze_helper.dart
+++ b/tests/compiler/dart2js/analyze_helper.dart
@@ -5,6 +5,7 @@
 library analyze_helper;
 
 import "package:expect/expect.dart";
+import 'dart:async';
 import 'dart:io';
 import '../../../sdk/lib/_internal/compiler/compiler.dart' as api;
 import '../../../sdk/lib/_internal/compiler/implementation/apiimpl.dart';
@@ -122,7 +123,7 @@ class CollectingDiagnosticHandler extends FormattingDiagnosticHandler {
   }
 }
 
-void analyze(List<Uri> uriList, Map<String, List<String>> whiteList) {
+Future analyze(List<Uri> uriList, Map<String, List<String>> whiteList) {
   var libraryRoot = currentDirectory.resolve('sdk/');
   var provider = new SourceFileProvider();
   var handler = new CollectingDiagnosticHandler(whiteList, provider);
@@ -134,6 +135,7 @@ void analyze(List<Uri> uriList, Map<String, List<String>> whiteList) {
       <String>['--analyze-only', '--analyze-all',
                '--categories=Client,Server']);
   compiler.librariesToAnalyzeWhenRun = uriList;
-  compiler.run(null);
-  handler.checkResults();
+  return compiler.run(null).then((_) {
+    handler.checkResults();
+  });
 }
diff --git a/tests/compiler/dart2js/analyze_only_test.dart b/tests/compiler/dart2js/analyze_only_test.dart
index 6ab98674dde..67bbeb8d4f7 100644
--- a/tests/compiler/dart2js/analyze_only_test.dart
+++ b/tests/compiler/dart2js/analyze_only_test.dart
@@ -7,6 +7,7 @@ library analyze_only;
 
 import "package:expect/expect.dart";
 import 'dart:async';
+import "package:async_helper/async_helper.dart";
 
 import '../../utils/dummy_compiler_test.dart' as dummy;
 import '../../../sdk/lib/_internal/compiler/compiler.dart';
@@ -34,6 +35,7 @@ runCompiler(String main, List<String> options,
   print('-----------------------------------------------');
   print('main source:\n$main');
   print('options: $options\n');
+  asyncStart();
   Future<String> result =
       compile(new Uri(scheme: 'main'),
               new Uri(scheme: 'lib', path: '/'),
@@ -43,7 +45,7 @@ runCompiler(String main, List<String> options,
     onValue(code, errors, warnings);
   }, onError: (e) {
       throw 'Compilation failed';
-  });
+  }).whenComplete(() => asyncEnd());
 }
 
 main() {
diff --git a/tests/compiler/dart2js/async_compiler_input_provider_test.dart b/tests/compiler/dart2js/async_compiler_input_provider_test.dart
new file mode 100644
index 00000000000..9b8a8264039
--- /dev/null
+++ b/tests/compiler/dart2js/async_compiler_input_provider_test.dart
@@ -0,0 +1,62 @@
+// 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.
+
+import "dart:async";
+import "dart:io";
+
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+import '../../../sdk/lib/_internal/compiler/compiler.dart' as compiler;
+import '../../../sdk/lib/_internal/compiler/implementation/filenames.dart';
+
+const SOURCES = const {
+  "/main.dart": """
+    import "foo.dart";
+    main() => foo();
+    """,
+  "/foo.dart": """
+    library foo;
+    import "bar.dart";
+    foo() => bar();
+    """,
+  "/bar.dart": """
+    library bar;
+    bar() => print("bar");
+    """
+};
+
+Future<String> provideInput(Uri uri) {
+  var source = SOURCES[uri.path];
+  if (source == null) {
+    // Not one of our source files, so assume it's a built-in.
+    source = new File(uriPathToNative(uri.path)).readAsStringSync();
+  }
+
+  // Deliver the input asynchronously.
+  return new Future(() => source);
+}
+
+main() {
+  var entrypoint = Uri.parse("file:///main.dart");
+
+  // Find the path to sdk/ in the repo relative to this script.
+  Uri script = currentDirectory.resolve(nativeToUriPath(Platform.script));
+  Uri libraryRoot = script.resolve('../../../sdk/');
+  Uri packageRoot = script.resolve('./packages/');
+
+  asyncStart();
+  compiler.compile(entrypoint, libraryRoot, packageRoot,
+      provideInput, handleDiagnostic, []).then((code) {
+    Expect.isNotNull(code);
+  }).whenComplete(() => asyncEnd());
+}
+
+void handleDiagnostic(Uri uri, int begin, int end, String message,
+                      compiler.Diagnostic kind) {
+  print(message);
+  if (kind != compiler.Diagnostic.VERBOSE_INFO) {
+    throw 'Unexpected diagnostic kind $kind';
+  }
+}
diff --git a/tests/compiler/dart2js/bad_loop_test.dart b/tests/compiler/dart2js/bad_loop_test.dart
index 5cecb22cf81..65629a453e8 100644
--- a/tests/compiler/dart2js/bad_loop_test.dart
+++ b/tests/compiler/dart2js/bad_loop_test.dart
@@ -4,6 +4,7 @@
 
 import 'package:expect/expect.dart';
 import 'memory_source_file_helper.dart';
+import "package:async_helper/async_helper.dart";
 
 import '../../../sdk/lib/_internal/compiler/compiler.dart'
        show Diagnostic;
@@ -13,8 +14,7 @@ main() {
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   int warningCount = 0;
   int errorCount = 0;
   void diagnosticHandler(Uri uri, int begin, int end,
@@ -37,10 +37,12 @@ main() {
                                    libraryRoot,
                                    packageRoot,
                                    ['--analyze-only']);
-  compiler.run(Uri.parse('memory:main.dart'));
-  Expect.isTrue(compiler.compilationFailed);
-  Expect.equals(5, errorCount);
-  Expect.equals(1, warningCount);
+  asyncStart();
+  compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    Expect.isTrue(compiler.compilationFailed);
+    Expect.equals(5, errorCount);
+    Expect.equals(1, warningCount);
+  }).whenComplete(() => asyncEnd());
 }
 
 const Map MEMORY_SOURCE_FILES = const {
diff --git a/tests/compiler/dart2js/call_site_simple_type_inferer_test.dart b/tests/compiler/dart2js/call_site_simple_type_inferer_test.dart
index 9c7e0cdcaa4..b568b199b13 100644
--- a/tests/compiler/dart2js/call_site_simple_type_inferer_test.dart
+++ b/tests/compiler/dart2js/call_site_simple_type_inferer_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show TypeMask;
 
@@ -15,12 +16,14 @@ void compileAndFind(String code,
                     bool disableInlining,
                     check(compiler, element)) {
   Uri uri = new Uri(scheme: 'source');
+  asyncStart();
   var compiler = compilerFor(code, uri);
   compiler.disableInlining = disableInlining;
-  compiler.runCompiler(uri);
-  var cls = findElement(compiler, className);
-  var member = cls.lookupLocalMember(buildSourceString(memberName));
-  return check(compiler, member);
+  compiler.runCompiler(uri).then((_) {
+    var cls = findElement(compiler, className);
+    var member = cls.lookupLocalMember(buildSourceString(memberName));
+    return check(compiler, member);
+  }).whenComplete(() => asyncEnd());
 }
 
 const String TEST_1 = r"""
diff --git a/tests/compiler/dart2js/class_codegen2_test.dart b/tests/compiler/dart2js/class_codegen2_test.dart
index 99e329d8068..458e1d328c9 100644
--- a/tests/compiler/dart2js/class_codegen2_test.dart
+++ b/tests/compiler/dart2js/class_codegen2_test.dart
@@ -3,7 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 // Test that parameters keep their names in the output.
 
+import 'dart:async';
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -87,15 +89,11 @@ main() {
   // At some point Dart2js generated bad object literals with dangling commas:
   // { a: true, }. Make sure this doesn't happen again.
   RegExp danglingComma = new RegExp(r',[ \n]*}');
-  String generated = compileAll(TEST_ONE);
-  Expect.isFalse(danglingComma.hasMatch(generated));
 
-  generated = compileAll(TEST_TWO);
-  Expect.isFalse(danglingComma.hasMatch(generated));
-
-  generated = compileAll(TEST_THREE);
-  Expect.isFalse(danglingComma.hasMatch(generated));
-
-  generated = compileAll(TEST_FOUR);
-  Expect.isFalse(danglingComma.hasMatch(generated));
+  asyncStart();
+  Future.forEach([TEST_ONE, TEST_TWO, TEST_THREE, TEST_FOUR], (test) {
+    return compileAll(test).then((generated) {
+      Expect.isFalse(danglingComma.hasMatch(generated));
+    });
+  }).whenComplete(() => asyncEnd());
 }
diff --git a/tests/compiler/dart2js/class_codegen_test.dart b/tests/compiler/dart2js/class_codegen_test.dart
index b4e72c19964..ed7c90c27a6 100644
--- a/tests/compiler/dart2js/class_codegen_test.dart
+++ b/tests/compiler/dart2js/class_codegen_test.dart
@@ -3,7 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 // Test that parameters keep their names in the output.
 
+import 'dart:async';
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -64,9 +66,10 @@ main() {
 """;
 
 twoClasses() {
-  String generated = compileAll(TEST_ONE);
-  Expect.isTrue(generated.contains('A: {"": "Object;"'));
-  Expect.isTrue(generated.contains('B: {"": "Object;"'));
+  asyncTest(() => compileAll(TEST_ONE).then((generated) {
+    Expect.isTrue(generated.contains('A: {"": "Object;"'));
+    Expect.isTrue(generated.contains('B: {"": "Object;"'));
+  }));
 }
 
 subClass() {
@@ -75,18 +78,20 @@ subClass() {
     Expect.isTrue(generated.contains('B: {"": "A;"'));
   }
 
-  checkOutput(compileAll(TEST_TWO));
-  checkOutput(compileAll(TEST_THREE));
+  asyncTest(() => compileAll(TEST_TWO).then(checkOutput));
+  asyncTest(() => compileAll(TEST_THREE).then(checkOutput));
 }
 
 fieldTest() {
-  String generated = compileAll(TEST_FOUR);
-  Expect.isTrue(generated.contains(r"""B: {"": "A;y,z,x", static:"""));
+  asyncTest(() => compileAll(TEST_FOUR).then((generated) {
+    Expect.isTrue(generated.contains(r"""B: {"": "A;y,z,x", static:"""));
+  }));
 }
 
 constructor1() {
-  String generated = compileAll(TEST_FIVE);
-  Expect.isTrue(generated.contains(new RegExp(r"new [$a-z]+\.A\(a\);")));
+  asyncTest(() => compileAll(TEST_FIVE).then((generated) {
+    Expect.isTrue(generated.contains(new RegExp(r"new [$a-z]+\.A\(a\);")));
+  }));
 }
 
 main() {
diff --git a/tests/compiler/dart2js/class_order_test.dart b/tests/compiler/dart2js/class_order_test.dart
index a4cc29e48ab..26850f0509f 100644
--- a/tests/compiler/dart2js/class_order_test.dart
+++ b/tests/compiler/dart2js/class_order_test.dart
@@ -4,6 +4,7 @@
 // Test that parameters keep their names in the output.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST_ONE = r"""
@@ -35,9 +36,11 @@ main() {
   // we just verify that their members are in the correct order.
   RegExp regexp = new RegExp(r"foo\$0?:(.|\n)*bar\$0:(.|\n)*gee\$0:");
 
-  String generated = compileAll(TEST_ONE);
-  Expect.isTrue(regexp.hasMatch(generated));
+  asyncTest(() => compileAll(TEST_ONE).then((generated) {
+    Expect.isTrue(regexp.hasMatch(generated));
+  }));
 
-  generated = compileAll(TEST_TWO);
-  Expect.isTrue(regexp.hasMatch(generated));
+  asyncTest(() => compileAll(TEST_TWO).then((generated) {
+    Expect.isTrue(regexp.hasMatch(generated));
+  }));
 }
diff --git a/tests/compiler/dart2js/closure_codegen_test.dart b/tests/compiler/dart2js/closure_codegen_test.dart
index b4399a84307..0474b0227b3 100644
--- a/tests/compiler/dart2js/closure_codegen_test.dart
+++ b/tests/compiler/dart2js/closure_codegen_test.dart
@@ -4,6 +4,7 @@
 // Test that parameters keep their names in the output.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -52,10 +53,11 @@ closureInvocation() {
 // Make sure that the bailout version does not introduce a second version of
 // the closure.
 closureBailout() {
-  String generated = compileAll(TEST_BAILOUT);
-  RegExp regexp = new RegExp(r'call\$0: function');
-  Iterator<Match> matches = regexp.allMatches(generated).iterator;
-  checkNumberOfMatches(matches, 1);
+  asyncTest(() => compileAll(TEST_BAILOUT).then((generated) {
+    RegExp regexp = new RegExp(r'call\$0: function');
+    Iterator<Match> matches = regexp.allMatches(generated).iterator;
+    checkNumberOfMatches(matches, 1);
+  }));
 }
 
 main() {
diff --git a/tests/compiler/dart2js/codegen_helper.dart b/tests/compiler/dart2js/codegen_helper.dart
index 4e8d4988587..1993ec54b07 100644
--- a/tests/compiler/dart2js/codegen_helper.dart
+++ b/tests/compiler/dart2js/codegen_helper.dart
@@ -2,19 +2,20 @@
 // 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.
 
+import 'dart:async';
 import 'package:expect/expect.dart';
 
 import 'memory_source_file_helper.dart';
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart"
     show SourceString;
 
-Map<String, String> generate(String code, [List<String> options = const []]) {
+Future<Map<String, String>> generate(String code,
+    [List<String> options = const []]) {
   Uri script = currentDirectory.resolve(nativeToUriPath(Platform.script));
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = { 'main.dart': code };
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider({ 'main.dart': code });
   var handler = new FormattingDiagnosticHandler(provider);
 
   Compiler compiler = new Compiler(provider.readStringFromUri,
@@ -24,13 +25,15 @@ Map<String, String> generate(String code, [List<String> options = const []]) {
                                    packageRoot,
                                    options);
   Uri uri = Uri.parse('memory:main.dart');
-  Expect.isTrue(compiler.run(uri));
-  Map<String, String> result = new Map<String, String>();
-  for (var element in compiler.backend.generatedCode.keys) {
-    if (element.getCompilationUnit().script.uri != uri) continue;
-    var name = element.name.slowToString();
-    var code = compiler.backend.assembleCode(element);
-    result[name] = code;
-  }
-  return result;
+  return compiler.run(uri).then((success) {
+    Expect.isTrue(success);
+    Map<String, String> result = new Map<String, String>();
+    for (var element in compiler.backend.generatedCode.keys) {
+      if (element.getCompilationUnit().script.uri != uri) continue;
+      var name = element.name.slowToString();
+      var code = compiler.backend.assembleCode(element);
+      result[name] = code;
+    }
+    return result;
+  });
 }
diff --git a/tests/compiler/dart2js/compiler_helper.dart b/tests/compiler/dart2js/compiler_helper.dart
index d891603487e..98aeb8a1ece 100644
--- a/tests/compiler/dart2js/compiler_helper.dart
+++ b/tests/compiler/dart2js/compiler_helper.dart
@@ -5,6 +5,7 @@
 
 library compiler_helper;
 
+import 'dart:async';
 import "package:expect/expect.dart";
 
 import '../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart'
@@ -90,40 +91,42 @@ MockCompiler compilerFor(String code, Uri uri,
   return compiler;
 }
 
-String compileAll(String code, {String coreSource: DEFAULT_CORELIB}) {
+Future<String> compileAll(String code, {String coreSource: DEFAULT_CORELIB}) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = compilerFor(code, uri, coreSource: coreSource);
-  compiler.runCompiler(uri);
-  Expect.isFalse(compiler.compilationFailed,
-                 'Unexpected compilation error');
-  return compiler.assembledCode;
+  return compiler.runCompiler(uri).then((_) {
+    Expect.isFalse(compiler.compilationFailed,
+                   'Unexpected compilation error');
+    return compiler.assembledCode;
+  });
 }
 
-dynamic compileAndCheck(String code,
-                        String name,
-                        check(MockCompiler compiler, lego.Element element)) {
+Future compileAndCheck(String code,
+                       String name,
+                       check(MockCompiler compiler, lego.Element element)) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = compilerFor(code, uri);
-  compiler.runCompiler(uri);
-  lego.Element element = findElement(compiler, name);
-  return check(compiler, element);
+  return compiler.runCompiler(uri).then((_) {
+    lego.Element element = findElement(compiler, name);
+    return check(compiler, element);
+  });
 }
 
-compileSources(Map<String, String> sources,
+Future compileSources(Map<String, String> sources,
                check(MockCompiler compiler)) {
   Uri base = new Uri(scheme: 'source');
   Uri mainUri = base.resolve('main.dart');
   String mainCode = sources['main.dart'];
   Expect.isNotNull(mainCode, 'No source code found for "main.dart"');
   MockCompiler compiler = compilerFor(mainCode, mainUri);
-
   sources.forEach((String path, String code) {
     if (path == 'main.dart') return;
     compiler.registerSource(base.resolve(path), code);
   });
 
-  compiler.runCompiler(mainUri);
-  return check(compiler);
+  return compiler.runCompiler(mainUri).then((_) {
+    return check(compiler);
+  });
 }
 
 lego.Element findElement(compiler, String name) {
diff --git a/tests/compiler/dart2js/concrete_type_inference_test.dart b/tests/compiler/dart2js/concrete_type_inference_test.dart
index fe95c4962a5..36d6f0ad1ef 100644
--- a/tests/compiler/dart2js/concrete_type_inference_test.dart
+++ b/tests/compiler/dart2js/concrete_type_inference_test.dart
@@ -2,21 +2,24 @@
 // 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.
 
+import 'dart:async';
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
-void compileAndFind(String code, String name,
+Future compileAndFind(String code, String name,
                     check(compiler, element)) {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(code, uri);
-  compiler.runCompiler(uri);
-  var element = findElement(compiler, name);
-  return check(compiler, element);
+  return compiler.runCompiler(uri).then((_) {
+    var element = findElement(compiler, name);
+    check(compiler, element);
+  });
 }
 
 void checkPrintType(String expression, checkType(compiler, type)) {
-  compileAndFind(
+  asyncTest(() => compileAndFind(
       'main() { print($expression); }',
       'print',
       (compiler, printElement) {
@@ -24,9 +27,9 @@ void checkPrintType(String expression, checkType(compiler, type)) {
           printElement.computeSignature(compiler).requiredParameters.head;
         var type = compiler.typesTask.getGuaranteedTypeOfElement(parameter);
         checkType(compiler, type);
-      });
+      }));
 
-  compileAndFind(
+  asyncTest(() => compileAndFind(
       'main() { var x = print; print($expression); }',
       'print',
       (compiler, printElement) {
@@ -36,9 +39,9 @@ void checkPrintType(String expression, checkType(compiler, type)) {
         var inferrer = compiler.typesTask.typesInferrer;
         Expect.identical(compiler.typesTask.dynamicType,
                          type.simplify(compiler));
-      });
+      }));
 
-  compileAndFind(
+  asyncTest(() => compileAndFind(
       'main() { print($expression); print($expression); }',
       'print',
       (compiler, printElement) {
@@ -46,7 +49,7 @@ void checkPrintType(String expression, checkType(compiler, type)) {
           printElement.computeSignature(compiler).requiredParameters.head;
         var type = compiler.typesTask.getGuaranteedTypeOfElement(parameter);
         checkType(compiler, type);
-      });
+      }));
 }
 
 void testBasicTypes() {
diff --git a/tests/compiler/dart2js/cpa_inference_test.dart b/tests/compiler/dart2js/cpa_inference_test.dart
index bbe7d385615..ab3b4bed5e1 100644
--- a/tests/compiler/dart2js/cpa_inference_test.dart
+++ b/tests/compiler/dart2js/cpa_inference_test.dart
@@ -2,7 +2,9 @@
 // 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.
 
+import 'dart:async';
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/concrete_types_inferrer.dart';
@@ -145,7 +147,7 @@ class AnalysisResult {
 
 const String CORELIB = r'''
   print(var obj) {}
-  abstract class num { 
+  abstract class num {
     num operator +(num x);
     num operator *(num x);
     num operator -(num x);
@@ -174,7 +176,7 @@ const String CORELIB = r'''
   class Dynamic_ {}
   bool identical(Object a, Object b) {}''';
 
-AnalysisResult analyze(String code, {int maxConcreteTypeSize: 1000}) {
+Future<AnalysisResult> analyze(String code, {int maxConcreteTypeSize: 1000}) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = new MockCompiler(
       coreSource: CORELIB,
@@ -182,8 +184,9 @@ AnalysisResult analyze(String code, {int maxConcreteTypeSize: 1000}) {
       maxConcreteTypeSize: maxConcreteTypeSize);
   compiler.sourceFiles[uri.toString()] = new SourceFile(uri.toString(), code);
   compiler.typesTask.concreteTypesInferrer.testMode = true;
-  compiler.runCompiler(uri);
-  return new AnalysisResult(compiler);
+  return compiler.runCompiler(uri).then((_) {
+    return new AnalysisResult(compiler);
+  });
 }
 
 testDynamicBackDoor() {
@@ -193,8 +196,9 @@ testDynamicBackDoor() {
       x;
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasUnknownType('x');
+  return analyze(source).then((result) {
+    result.checkNodeHasUnknownType('x');
+  });
 }
 
 testVariableDeclaration() {
@@ -206,9 +210,10 @@ testVariableDeclaration() {
         v1; v2;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('v1', [result.nullType]);
-  result.checkNodeHasType('v2', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('v1', [result.nullType]);
+    result.checkNodeHasType('v2', [result.int]);
+  });
 }
 
 testLiterals() {
@@ -222,12 +227,13 @@ testLiterals() {
         v1; v2; v3; v4; v5;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('v1', [result.int]);
-  result.checkNodeHasType('v2', [result.double]);
-  result.checkNodeHasType('v3', [result.string]);
-  result.checkNodeHasType('v4', [result.bool]);
-  result.checkNodeHasType('v5', [result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('v1', [result.int]);
+    result.checkNodeHasType('v2', [result.double]);
+    result.checkNodeHasType('v3', [result.string]);
+    result.checkNodeHasType('v4', [result.bool]);
+    result.checkNodeHasType('v5', [result.nullType]);
+  });
 }
 
 testRedefinition() {
@@ -238,8 +244,9 @@ testRedefinition() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.string]);
+  });
 }
 
 testIfThenElse() {
@@ -254,8 +261,9 @@ testIfThenElse() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.string, result.bool]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.string, result.bool]);
+  });
 }
 
 testTernaryIf() {
@@ -266,8 +274,9 @@ testTernaryIf() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.string, result.bool]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.string, result.bool]);
+  });
 }
 
 testWhile() {
@@ -284,12 +293,13 @@ testWhile() {
         foo; bar;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType(
-      'foo',
-      [result.base('A'), result.base('B'), result.base('C')]);
-  // Check that the condition is evaluated.
-  result.checkNodeHasType('bar', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType(
+        'foo',
+        [result.base('A'), result.base('B'), result.base('C')]);
+    // Check that the condition is evaluated.
+    result.checkNodeHasType('bar', [result.int]);
+  });
 }
 
 testDoWhile() {
@@ -306,12 +316,13 @@ testDoWhile() {
         foo; bar;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType(
-      'foo',
-      [result.base('A'), result.base('B'), result.base('C')]);
-  // Check that the condition is evaluated.
-  result.checkNodeHasType('bar', [result.int]);
+  return analyze(source).then((AnalysisResult result) {
+    result.checkNodeHasType(
+        'foo',
+        [result.base('A'), result.base('B'), result.base('C')]);
+    // Check that the condition is evaluated.
+    result.checkNodeHasType('bar', [result.int]);
+  });
 }
 
 testFor1() {
@@ -327,10 +338,11 @@ testFor1() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType(
-      'foo',
-      [result.base('A'), result.base('B'), result.base('C')]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType(
+        'foo',
+        [result.base('A'), result.base('B'), result.base('C')]);
+  });
 }
 
 testFor2() {
@@ -346,10 +358,11 @@ testFor2() {
         foo; bar;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.base('A'), result.base('B')]);
-  // Check that the condition is evaluated.
-  result.checkNodeHasType('bar', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.base('A'), result.base('B')]);
+    // Check that the condition is evaluated.
+    result.checkNodeHasType('bar', [result.int]);
+  });
 }
 
 testFor3() {
@@ -363,8 +376,9 @@ testFor3() {
         i;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('i', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('i', [result.int]);
+  });
 }
 
 testForIn() {
@@ -399,8 +413,10 @@ testForIn() {
         res;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('res', [result.int, result.string, result.nullType]);
+  return analyze(source).then((AnalysisResult result) {
+    result.checkNodeHasType('res',
+        [result.int, result.string, result.nullType]);
+  });
 }
 
 testToplevelVariable() {
@@ -409,15 +425,16 @@ testToplevelVariable() {
       class A {
          f() => top;
       }
-      main() { 
+      main() {
         var foo = top;
         var bar = new A().f();
         foo; bar;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.string]);
-  result.checkNodeHasType('bar', [result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.string]);
+    result.checkNodeHasType('bar', [result.string]);
+  });
 }
 
 testNonRecusiveFunction() {
@@ -425,8 +442,9 @@ testNonRecusiveFunction() {
       f(x, y) => true ? x : y;
       main() { var foo = f(42, "abc"); foo; }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int, result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int, result.string]);
+  });
 }
 
 testRecusiveFunction() {
@@ -437,18 +455,20 @@ testRecusiveFunction() {
       }
       main() { var foo = f(42); foo; }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int, result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int, result.string]);
+  });
 }
 
 testMutuallyRecusiveFunction() {
   final String source = r"""
       f() => true ? 42 : g();
-      g() => true ? "abc" : f(); 
+      g() => true ? "abc" : f();
       main() { var foo = f(); foo; }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int, result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int, result.string]);
+  });
 }
 
 testSimpleSend() {
@@ -463,7 +483,7 @@ testSimpleSend() {
         f(x) => 3.14;
       }
       class D {
-        var f;  // we check that this field is ignored in calls to dynamic.f() 
+        var f;  // we check that this field is ignored in calls to dynamic.f()
         D(this.f);
       }
       main() {
@@ -473,9 +493,10 @@ testSimpleSend() {
         foo; bar;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int]);
-  result.checkNodeHasType('bar', [result.int, result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int]);
+    result.checkNodeHasType('bar', [result.int, result.string]);
+  });
 }
 
 testSendToClosureField() {
@@ -490,8 +511,9 @@ testSendToClosureField() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int]);
+  });
 }
 
 testSendToThis1() {
@@ -506,8 +528,9 @@ testSendToThis1() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int]);
+  });
 }
 
 testSendToThis2() {
@@ -523,8 +546,9 @@ testSendToThis2() {
         x;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.base('B')]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.base('B')]);
+  });
 }
 
 testSendToThis3() {
@@ -541,8 +565,9 @@ testSendToThis3() {
         x;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.string]);
+  return analyze(source).then((AnalysisResult result) {
+    result.checkNodeHasType('x', [result.string]);
+  });
 }
 
 testConstructor() {
@@ -556,11 +581,12 @@ testConstructor() {
         new A(true, null);
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkFieldHasType('A', 'x', [result.int, result.bool]);
-  result.checkFieldHasType('A', 'y', [result.string, result.nullType]);
-  // TODO(polux): we can be smarter and infer {string} for z
-  result.checkFieldHasType('A', 'z', [result.string, result.nullType]);
+  return analyze(source).then((result) {
+    result.checkFieldHasType('A', 'x', [result.int, result.bool]);
+    result.checkFieldHasType('A', 'y', [result.string, result.nullType]);
+    // TODO(polux): we can be smarter and infer {string} for z
+    result.checkFieldHasType('A', 'z', [result.string, result.nullType]);
+  });
 }
 
 testGetters() {
@@ -586,12 +612,13 @@ testGetters() {
         foo; bar; baz; qux; quux;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int]);
-  result.checkNodeHasType('bar', [result.int]);
-  result.checkNodeHasType('baz', [result.int]);
-  result.checkNodeHasType('qux', []);
-  result.checkNodeHasType('quux', [result.int, result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int]);
+    result.checkNodeHasType('bar', [result.int]);
+    result.checkNodeHasType('baz', [result.int]);
+    result.checkNodeHasType('qux', []);
+    result.checkNodeHasType('quux', [result.int, result.string]);
+  });
 }
 
 testSetters() {
@@ -617,20 +644,21 @@ testSetters() {
         "__dynamic_for_test".y = 3.14;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkFieldHasType('B', 'x',
-                           [result.int,         // new B(42)
-                            result.nullType]);  // dynamic.x = null
-  result.checkFieldHasType('A', 'x',
-                           [result.int,       // new A(42, ...)
-                            result.string,    // a.x = 'abc'
-                            result.bool,      // a.y = true
-                            result.nullType,  // dynamic.x = null
-                            result.double]);  // dynamic.y = 3.14
-  result.checkFieldHasType('A', 'w',
-                           [result.int,       // new A(..., 42)
-                            result.bool,      // a.y = true
-                            result.double]);  // dynamic.y = double
+  return analyze(source).then((result) {
+    result.checkFieldHasType('B', 'x',
+                             [result.int,         // new B(42)
+                              result.nullType]);  // dynamic.x = null
+    result.checkFieldHasType('A', 'x',
+                             [result.int,       // new A(42, ...)
+                              result.string,    // a.x = 'abc'
+                              result.bool,      // a.y = true
+                              result.nullType,  // dynamic.x = null
+                              result.double]);  // dynamic.y = 3.14
+    result.checkFieldHasType('A', 'w',
+                             [result.int,       // new A(..., 42)
+                              result.bool,      // a.y = true
+                              result.double]);  // dynamic.y = double
+  });
 }
 
 testOptionalNamedParameters() {
@@ -695,29 +723,30 @@ testOptionalNamedParameters() {
         test.f3(1, z: 2);  // non-existing named parameter
       }
       """;
-  AnalysisResult result = analyze(source);
+  return analyze(source).then((result) {
 
-  final foo = result.base('Foo');
-  final nil = result.nullType;
+    final foo = result.base('Foo');
+    final nil = result.nullType;
 
-  result.checkFieldHasType('A', 'x', [result.int, result.string]);
-  result.checkFieldHasType('A', 'y', [nil]);
-  result.checkFieldHasType('A', 'z', [nil, result.double]);
-  result.checkFieldHasType('A', 'w', [nil, result.bool]);
-  result.checkFieldHasType('Test', 'a', [foo, result.int, result.string]);
-  result.checkFieldHasType('Test', 'b', [foo, nil]);
-  result.checkFieldHasType('Test', 'c', [foo, nil, result.double]);
-  result.checkFieldHasType('Test', 'd', [foo, nil, result.bool]);
+    result.checkFieldHasType('A', 'x', [result.int, result.string]);
+    result.checkFieldHasType('A', 'y', [nil]);
+    result.checkFieldHasType('A', 'z', [nil, result.double]);
+    result.checkFieldHasType('A', 'w', [nil, result.bool]);
+    result.checkFieldHasType('Test', 'a', [foo, result.int, result.string]);
+    result.checkFieldHasType('Test', 'b', [foo, nil]);
+    result.checkFieldHasType('Test', 'c', [foo, nil, result.double]);
+    result.checkFieldHasType('Test', 'd', [foo, nil, result.bool]);
 
-  result.checkFieldHasType('B', 'x', [result.string]);
-  result.checkFieldHasType('B', 'y', [result.bool]);
-  result.checkFieldHasType('Test', 'e', [foo, result.string]);
-  result.checkFieldHasType('Test', 'f', [foo, result.bool]);
+    result.checkFieldHasType('B', 'x', [result.string]);
+    result.checkFieldHasType('B', 'y', [result.bool]);
+    result.checkFieldHasType('Test', 'e', [foo, result.string]);
+    result.checkFieldHasType('Test', 'f', [foo, result.bool]);
 
-  result.checkFieldHasType('C', 'x', [result.string]);
-  result.checkFieldHasType('C', 'y', [result.bool]);
-  result.checkFieldHasType('Test', 'g', [foo, result.string]);
-  result.checkFieldHasType('Test', 'h', [foo, result.bool]);
+    result.checkFieldHasType('C', 'x', [result.string]);
+    result.checkFieldHasType('C', 'y', [result.bool]);
+    result.checkFieldHasType('Test', 'g', [foo, result.string]);
+    result.checkFieldHasType('Test', 'h', [foo, result.bool]);
+  });
 }
 
 testOptionalPositionalParameters() {
@@ -767,24 +796,25 @@ testOptionalPositionalParameters() {
       test.f2(1, 2, 3);  // too many arguments
     }
   """;
-  AnalysisResult result = analyze(source);
+  return analyze(source).then((result) {
 
-  final foo = result.base('Foo');
-  final nil = result.nullType;
+    final foo = result.base('Foo');
+    final nil = result.nullType;
 
-  result.checkFieldHasType('A', 'x', [result.int, result.string]);
-  result.checkFieldHasType('A', 'y', [nil, result.bool]);
-  result.checkFieldHasType('A', 'z', [nil, result.double]);
-  result.checkFieldHasType('A', 'w', [nil]);
-  result.checkFieldHasType('Test', 'a', [foo, result.int, result.string]);
-  result.checkFieldHasType('Test', 'b', [foo, nil, result.bool]);
-  result.checkFieldHasType('Test', 'c', [foo, nil, result.double]);
-  result.checkFieldHasType('Test', 'd', [foo, nil]);
+    result.checkFieldHasType('A', 'x', [result.int, result.string]);
+    result.checkFieldHasType('A', 'y', [nil, result.bool]);
+    result.checkFieldHasType('A', 'z', [nil, result.double]);
+    result.checkFieldHasType('A', 'w', [nil]);
+    result.checkFieldHasType('Test', 'a', [foo, result.int, result.string]);
+    result.checkFieldHasType('Test', 'b', [foo, nil, result.bool]);
+    result.checkFieldHasType('Test', 'c', [foo, nil, result.double]);
+    result.checkFieldHasType('Test', 'd', [foo, nil]);
 
-  result.checkFieldHasType('B', 'x', [result.string]);
-  result.checkFieldHasType('B', 'y', [result.bool]);
-  result.checkFieldHasType('Test', 'e', [foo, result.string]);
-  result.checkFieldHasType('Test', 'f', [foo, result.bool]);
+    result.checkFieldHasType('B', 'x', [result.string]);
+    result.checkFieldHasType('B', 'y', [result.bool]);
+    result.checkFieldHasType('Test', 'e', [foo, result.string]);
+    result.checkFieldHasType('Test', 'f', [foo, result.bool]);
+  });
 }
 
 testListLiterals() {
@@ -799,10 +829,11 @@ testListLiterals() {
         x; y;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.growableList]);
-  result.checkNodeHasType('y', [result.growableList]);
-  result.checkFieldHasType('A', 'x', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.growableList]);
+    result.checkNodeHasType('y', [result.growableList]);
+    result.checkFieldHasType('A', 'x', [result.int]);
+  });
 }
 
 testMapLiterals() {
@@ -817,10 +848,11 @@ testMapLiterals() {
         x; y;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.map]);
-  result.checkNodeHasType('y', [result.map]);
-  result.checkFieldHasType('A', 'x', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.map]);
+    result.checkNodeHasType('y', [result.map]);
+    result.checkFieldHasType('A', 'x', [result.int]);
+  });
 }
 
 testReturn() {
@@ -833,9 +865,10 @@ testReturn() {
         x; y;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.int, result.string]);
-  result.checkNodeHasType('y', [result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.int, result.string]);
+    result.checkNodeHasType('y', [result.nullType]);
+  });
 }
 
 testNoReturn() {
@@ -848,9 +881,10 @@ testNoReturn() {
         x; y;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.int, result.nullType]);
-  result.checkNodeHasType('y', [result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.int, result.nullType]);
+    result.checkNodeHasType('y', [result.nullType]);
+  });
 }
 
 testArithmeticOperators() {
@@ -872,21 +906,22 @@ testArithmeticOperators() {
           a; b; c; d; e; f; g; h; i; j; k; l;
         }""";
   }
-  for (String op in ['+', '*', '-']) {
-    AnalysisResult result = analyze(source(op));
-    result.checkNodeHasType('a', [result.int]);
-    result.checkNodeHasType('b', [result.num]);
-    result.checkNodeHasType('c', [result.num]);
-    result.checkNodeHasType('d', [result.double]);
-    result.checkNodeHasType('e', [result.num]);
-    result.checkNodeHasType('f', [result.num]);
-    result.checkNodeHasType('g', [result.num]);
-    result.checkNodeHasType('h', [result.num]);
-    result.checkNodeHasType('i', [result.int]);
-    result.checkNodeHasType('j', [result.int]);
-    result.checkNodeHasType('k', [result.double]);
-    result.checkNodeHasType('l', [result.double]);
-  }
+  return Future.forEach(['+', '*', '-'], (String op) {
+    return analyze(source(op)).then((result) {
+      result.checkNodeHasType('a', [result.int]);
+      result.checkNodeHasType('b', [result.num]);
+      result.checkNodeHasType('c', [result.num]);
+      result.checkNodeHasType('d', [result.double]);
+      result.checkNodeHasType('e', [result.num]);
+      result.checkNodeHasType('f', [result.num]);
+      result.checkNodeHasType('g', [result.num]);
+      result.checkNodeHasType('h', [result.num]);
+      result.checkNodeHasType('i', [result.int]);
+      result.checkNodeHasType('j', [result.int]);
+      result.checkNodeHasType('k', [result.double]);
+      result.checkNodeHasType('l', [result.double]);
+    });
+  });
 }
 
 testBooleanOperators() {
@@ -900,13 +935,14 @@ testBooleanOperators() {
           a; b; c; d;
         }""";
   }
-  for (String op in ['&&', '||']) {
-    AnalysisResult result = analyze(source(op));
-    result.checkNodeHasType('a', [result.bool]);
-    result.checkNodeHasType('b', [result.bool]);
-    result.checkNodeHasType('c', [result.bool]);
-    result.checkNodeHasType('d', [result.bool]);
-  }
+  return Future.forEach(['&&', '||'], (String op) {
+    return analyze(source(op)).then((result) {
+      result.checkNodeHasType('a', [result.bool]);
+      result.checkNodeHasType('b', [result.bool]);
+      result.checkNodeHasType('c', [result.bool]);
+      result.checkNodeHasType('d', [result.bool]);
+    });
+  });
 }
 
 testBooleanOperatorsShortCirtcuit() {
@@ -918,10 +954,11 @@ testBooleanOperatorsShortCirtcuit() {
           x;
         }""";
   }
-  for (String op in ['&&', '||']) {
-    AnalysisResult result = analyze(source(op));
-    result.checkNodeHasType('x', [result.nullType, result.int]);
-  }
+  return Future.forEach(['&&', '||'], (String op) {
+    return analyze(source(op)).then((AnalysisResult result) {
+      result.checkNodeHasType('x', [result.nullType, result.int]);
+    });
+  });
 }
 
 testOperators() {
@@ -936,9 +973,10 @@ testOperators() {
         x; y;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.int]);
-  result.checkNodeHasType('y', [result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.int]);
+    result.checkNodeHasType('y', [result.string]);
+  });
 }
 
 testSetIndexOperator() {
@@ -953,10 +991,11 @@ testSetIndexOperator() {
         x;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.string]);
-  result.checkFieldHasType('A', 'witness1', [result.int, result.nullType]);
-  result.checkFieldHasType('A', 'witness2', [result.string, result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.string]);
+    result.checkFieldHasType('A', 'witness1', [result.int, result.nullType]);
+    result.checkFieldHasType('A', 'witness2', [result.string, result.nullType]);
+  });
 }
 
 testCompoundOperators1() {
@@ -981,13 +1020,14 @@ testCompoundOperators1() {
         x1; x2; x3; x4; x5; x6;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x1', [result.int]);
-  result.checkNodeHasType('x2', [result.int]);
-  result.checkNodeHasType('x3', [result.int]);
-  result.checkNodeHasType('x4', [result.string]);
-  result.checkNodeHasType('x5', [result.string]);
-  result.checkNodeHasType('x6', [result.string]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x1', [result.int]);
+    result.checkNodeHasType('x2', [result.int]);
+    result.checkNodeHasType('x3', [result.int]);
+    result.checkNodeHasType('x4', [result.string]);
+    result.checkNodeHasType('x5', [result.string]);
+    result.checkNodeHasType('x6', [result.string]);
+  });
 }
 
 
@@ -1010,16 +1050,17 @@ testCompoundOperators2() {
     main () {
       var a = new A(1, 1);
       a.x++;
-      a.y++; 
+      a.y++;
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkFieldHasType('A', 'xx', [result.int]);
-  result.checkFieldHasType('A', 'yy', [result.int]);
-  result.checkFieldHasType('A', 'witness1', [result.string, result.nullType]);
-  result.checkFieldHasType('A', 'witness2', [result.string, result.nullType]);
-  result.checkFieldHasType('A', 'witness3', [result.string, result.nullType]);
-  result.checkFieldHasType('A', 'witness4', [result.string, result.nullType]);
+  return analyze(source).then((result) {
+    result.checkFieldHasType('A', 'xx', [result.int]);
+    result.checkFieldHasType('A', 'yy', [result.int]);
+    result.checkFieldHasType('A', 'witness1', [result.string, result.nullType]);
+    result.checkFieldHasType('A', 'witness2', [result.string, result.nullType]);
+    result.checkFieldHasType('A', 'witness3', [result.string, result.nullType]);
+    result.checkFieldHasType('A', 'witness4', [result.string, result.nullType]);
+  });
 }
 
 testInequality() {
@@ -1038,11 +1079,12 @@ testInequality() {
         foo; bar; baz;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.bool]);
-  result.checkNodeHasType('bar', [result.bool]);
-  result.checkNodeHasType('baz', []);
-  result.checkFieldHasType('A', 'witness', [result.string, result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.bool]);
+    result.checkNodeHasType('bar', [result.bool]);
+    result.checkNodeHasType('baz', []);
+    result.checkFieldHasType('A', 'witness', [result.string, result.nullType]);
+  });
 }
 
 testFieldInitialization1() {
@@ -1058,10 +1100,11 @@ testFieldInitialization1() {
       new B();
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkFieldHasType('A', 'x', [result.nullType]);
-  result.checkFieldHasType('A', 'y', [result.int]);
-  result.checkFieldHasType('B', 'z', [result.string]);
+  return analyze(source).then((result) {
+    result.checkFieldHasType('A', 'x', [result.nullType]);
+    result.checkFieldHasType('A', 'y', [result.int]);
+    result.checkFieldHasType('B', 'z', [result.string]);
+  });
 }
 
 testFieldInitialization2() {
@@ -1074,8 +1117,9 @@ testFieldInitialization2() {
       new A();
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkFieldHasType('A', 'x', [result.int]);
+  return analyze(source).then((result) {
+    result.checkFieldHasType('A', 'x', [result.int]);
+  });
 }
 
 testFieldInitialization3() {
@@ -1095,15 +1139,16 @@ testFieldInitialization3() {
       foo; bar;
     }
     """;
-  AnalysisResult result = analyze(source);
-  // checks that B.B is set as a reader of A.x
-  result.checkFieldHasType('B', 'x', [result.nullType, result.string]);
-  // checks that B.B is set as a caller of f
-  result.checkFieldHasType('B', 'y', [result.nullType, result.string]);
-  // checks that readers of x are notified by changes in x's type
-  result.checkNodeHasType('foo', [result.nullType, result.string]);
-  // checks that readers of y are notified by changes in y's type
-  result.checkNodeHasType('bar', [result.nullType, result.string]);
+  return analyze(source).then((result) {
+    // checks that B.B is set as a reader of A.x
+    result.checkFieldHasType('B', 'x', [result.nullType, result.string]);
+    // checks that B.B is set as a caller of f
+    result.checkFieldHasType('B', 'y', [result.nullType, result.string]);
+    // checks that readers of x are notified by changes in x's type
+    result.checkNodeHasType('foo', [result.nullType, result.string]);
+    // checks that readers of y are notified by changes in y's type
+    result.checkNodeHasType('bar', [result.nullType, result.string]);
+  });
 }
 
 testLists() {
@@ -1135,16 +1180,17 @@ testLists() {
       var x8 = l2.removeLast();
       x1; x2; x3; x4; x5; x6; x7; x8;
     }""";
-  AnalysisResult result = analyze(source);
-  final expectedTypes = ['A', 'C', 'D', 'F', 'G'].map(result.base).toList();
-  result.checkNodeHasType('x1', expectedTypes);
-  result.checkNodeHasType('x2', expectedTypes);
-  result.checkNodeHasType('x3', []);
-  result.checkNodeHasType('x4', expectedTypes);
-  result.checkNodeHasType('x5', expectedTypes);
-  result.checkNodeHasType('x6', []);
-  result.checkNodeHasType('x7', expectedTypes);
-  result.checkNodeHasType('x8', expectedTypes);
+  return analyze(source).then((result) {
+    final expectedTypes = ['A', 'C', 'D', 'F', 'G'].map(result.base).toList();
+    result.checkNodeHasType('x1', expectedTypes);
+    result.checkNodeHasType('x2', expectedTypes);
+    result.checkNodeHasType('x3', []);
+    result.checkNodeHasType('x4', expectedTypes);
+    result.checkNodeHasType('x5', expectedTypes);
+    result.checkNodeHasType('x6', []);
+    result.checkNodeHasType('x7', expectedTypes);
+    result.checkNodeHasType('x8', expectedTypes);
+  });
 }
 
 testListWithCapacity() {
@@ -1154,8 +1200,9 @@ testListWithCapacity() {
       var x = [][0];
       x;
     }""";
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.nullType]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.nullType]);
+  });
 }
 
 testEmptyList() {
@@ -1165,8 +1212,9 @@ testEmptyList() {
       var x = l[0];
       x;
     }""";
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', []);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', []);
+  });
 }
 
 testSendWithWrongArity() {
@@ -1181,11 +1229,12 @@ testSendWithWrongArity() {
       x; y; z; w;
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', []);
-  result.checkNodeHasType('y', []);
-  result.checkNodeHasType('z', []);
-  result.checkNodeHasType('w', []);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', []);
+    result.checkNodeHasType('y', []);
+    result.checkNodeHasType('z', []);
+    result.checkNodeHasType('w', []);
+  });
 }
 
 testBigTypesWidening1() {
@@ -1198,9 +1247,10 @@ testBigTypesWidening1() {
       x; y;
     }
     """;
-  AnalysisResult result = analyze(source, maxConcreteTypeSize: 2);
-  result.checkNodeHasType('x', [result.int, result.string]);
-  result.checkNodeHasUnknownType('y');
+  return analyze(source, maxConcreteTypeSize: 2).then((result) {
+    result.checkNodeHasType('x', [result.int, result.string]);
+    result.checkNodeHasUnknownType('y');
+  });
 }
 
 testBigTypesWidening2() {
@@ -1216,9 +1266,10 @@ testBigTypesWidening2() {
       a.y = true;
     }
     """;
-  AnalysisResult result = analyze(source, maxConcreteTypeSize: 2);
-  result.checkFieldHasType('A', 'x', [result.int, result.string]);
-  result.checkFieldHasUknownType('A', 'y');
+  return analyze(source, maxConcreteTypeSize: 2).then((result) {
+    result.checkFieldHasType('A', 'x', [result.int, result.string]);
+    result.checkFieldHasUknownType('A', 'y');
+  });
 }
 
 testDynamicIsAbsorbing() {
@@ -1233,8 +1284,9 @@ testDynamicIsAbsorbing() {
       x;
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasUnknownType('x');
+  return analyze(source).then((result) {
+    result.checkNodeHasUnknownType('x');
+  });
 }
 
 testJsCall() {
@@ -1279,34 +1331,35 @@ testJsCall() {
       iNull; j;
     }
     """;
-  AnalysisResult result = analyze(source);
-  List maybe(List types) => new List.from(types)..add(result.nullType);
-  result.checkNodeHasUnknownType('a');
-  result.checkNodeHasUnknownType('b');
-  final expectedCType = [result.growableList];
-  result.checkNodeHasType('c', expectedCType);
-  result.checkNodeHasType('cNull', maybe(expectedCType));
-  final expectedDType = [result.string];
-  result.checkNodeHasType('d', expectedDType);
-  result.checkNodeHasType('dNull', maybe(expectedDType));
-  final expectedEType = [result.int];
-  result.checkNodeHasType('e', expectedEType);
-  result.checkNodeHasType('eNull', maybe(expectedEType));
-  final expectedFType = [result.double];
-  result.checkNodeHasType('f', expectedFType);
-  result.checkNodeHasType('fNull', maybe(expectedFType));
-  final expectedGType = [result.num];
-  result.checkNodeHasType('g', expectedGType);
-  result.checkNodeHasType('gNull', maybe(expectedGType));
-  final expectedHType = [result.bool];
-  result.checkNodeHasType('h', expectedHType);
-  result.checkNodeHasType('hNull', maybe(expectedHType));
-  final expectedIType = [result.base('A'), result.base('B'),
-                         result.base('BB'), result.base('C'),
-                         result.base('D')];
-  result.checkNodeHasType('i', expectedIType);
-  result.checkNodeHasType('iNull', maybe(expectedIType));
-  result.checkNodeHasType('j', []);
+  return analyze(source).then((result) {
+    List maybe(List types) => new List.from(types)..add(result.nullType);
+    result.checkNodeHasUnknownType('a');
+    result.checkNodeHasUnknownType('b');
+    final expectedCType = [result.growableList];
+    result.checkNodeHasType('c', expectedCType);
+    result.checkNodeHasType('cNull', maybe(expectedCType));
+    final expectedDType = [result.string];
+    result.checkNodeHasType('d', expectedDType);
+    result.checkNodeHasType('dNull', maybe(expectedDType));
+    final expectedEType = [result.int];
+    result.checkNodeHasType('e', expectedEType);
+    result.checkNodeHasType('eNull', maybe(expectedEType));
+    final expectedFType = [result.double];
+    result.checkNodeHasType('f', expectedFType);
+    result.checkNodeHasType('fNull', maybe(expectedFType));
+    final expectedGType = [result.num];
+    result.checkNodeHasType('g', expectedGType);
+    result.checkNodeHasType('gNull', maybe(expectedGType));
+    final expectedHType = [result.bool];
+    result.checkNodeHasType('h', expectedHType);
+    result.checkNodeHasType('hNull', maybe(expectedHType));
+    final expectedIType = [result.base('A'), result.base('B'),
+                           result.base('BB'), result.base('C'),
+                           result.base('D')];
+    result.checkNodeHasType('i', expectedIType);
+    result.checkNodeHasType('iNull', maybe(expectedIType));
+    result.checkNodeHasType('j', []);
+  });
 }
 
 testJsCallAugmentsSeenClasses() {
@@ -1316,20 +1369,23 @@ testJsCallAugmentsSeenClasses() {
       x;
     }
     """;
-  AnalysisResult result1 = analyze(source1);
-  result1.checkNodeHasType('x', []);
+  return analyze(source1).then((AnalysisResult result) {
+    result.checkNodeHasType('x', []);
+  }).whenComplete(() {
 
-  final String source2 = r"""
-    import 'dart:foreign';
-
-    main () {
-      var x = "__dynamic_for_test".truncate();
-      JS('double', 'foo');
-      x;
-    }
-    """;
-  AnalysisResult result2 = analyze(source2);
-  result2.checkNodeHasType('x', [result2.int]);
+    final String source2 = r"""
+      import 'dart:foreign';
+  
+      main () {
+        var x = "__dynamic_for_test".truncate();
+        JS('double', 'foo');
+        x;
+      }
+      """;
+    return analyze(source2).then((AnalysisResult result) {
+      result.checkNodeHasType('x', [result.int]);
+    });
+  });
 }
 
 testIsCheck() {
@@ -1339,8 +1395,9 @@ testIsCheck() {
       x;
     }
     """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.bool]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.bool]);
+  });
 }
 
 testSeenClasses() {
@@ -1366,8 +1423,9 @@ testSeenClasses() {
         foo;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('foo', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('foo', [result.int]);
+  });
 }
 
 testIntDoubleNum() {
@@ -1379,10 +1437,11 @@ testIntDoubleNum() {
         a; b; c;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('a', [result.int]);
-  result.checkNodeHasType('b', [result.double]);
-  result.checkNodeHasType('c', [result.num]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('a', [result.int]);
+    result.checkNodeHasType('b', [result.double]);
+    result.checkNodeHasType('c', [result.num]);
+  });
 }
 
 testConcreteTypeToTypeMask() {
@@ -1398,46 +1457,48 @@ testConcreteTypeToTypeMask() {
         new D();
       }
       """;
-  AnalysisResult result = analyze(source);
+  return analyze(source).then((result) {
 
-  convert(ConcreteType type) {
-    return result.compiler.typesTask.concreteTypesInferrer
-        .concreteTypeToTypeMask(type);
-  }
+    convert(ConcreteType type) {
+      return result.compiler.typesTask.concreteTypesInferrer
+          .concreteTypeToTypeMask(type);
+    }
 
-  final nullSingleton =
-      result.compiler.typesTask.concreteTypesInferrer.singletonConcreteType(
-          new NullBaseType());
+    final nullSingleton =
+        result.compiler.typesTask.concreteTypesInferrer.singletonConcreteType(
+            new NullBaseType());
 
-  singleton(ClassElement element) {
-    return result.compiler.typesTask.concreteTypesInferrer
-        .singletonConcreteType(new ClassBaseType(element));
-  }
+    singleton(ClassElement element) {
+      return result.compiler.typesTask.concreteTypesInferrer
+          .singletonConcreteType(new ClassBaseType(element));
+    }
 
-  ClassElement a = findElement(result.compiler, 'A');
-  ClassElement b = findElement(result.compiler, 'B');
-  ClassElement c = findElement(result.compiler, 'C');
-  ClassElement d = findElement(result.compiler, 'D');
+    ClassElement a = findElement(result.compiler, 'A');
+    ClassElement b = findElement(result.compiler, 'B');
+    ClassElement c = findElement(result.compiler, 'C');
+    ClassElement d = findElement(result.compiler, 'D');
 
-  for (ClassElement cls in [a, b, c, d]) {
-    Expect.equals(convert(singleton(cls)),
-                  new TypeMask.nonNullExact(cls.rawType));
-  }
+    for (ClassElement cls in [a, b, c, d]) {
+      Expect.equals(convert(singleton(cls)),
+                    new TypeMask.nonNullExact(cls.rawType));
+    }
 
-  for (ClassElement cls in [a, b, c, d]) {
-    Expect.equals(convert(singleton(cls).union(nullSingleton)),
-                  new TypeMask.exact(cls.rawType));
-  }
+    for (ClassElement cls in [a, b, c, d]) {
+      Expect.equals(convert(singleton(cls).union(nullSingleton)),
+                    new TypeMask.exact(cls.rawType));
+    }
 
-  Expect.equals(convert(singleton(a).union(singleton(b))),
-                new TypeMask.nonNullSubclass(a.rawType));
+    Expect.equals(convert(singleton(a).union(singleton(b))),
+                  new TypeMask.nonNullSubclass(a.rawType));
 
-  Expect.equals(convert(singleton(a).union(singleton(b)).union(nullSingleton)),
-                new TypeMask.subclass(a.rawType));
+    Expect.equals(
+        convert(singleton(a).union(singleton(b)).union(nullSingleton)),
+                  new TypeMask.subclass(a.rawType));
 
-  Expect.equals(
-      convert(singleton(b).union(singleton(d))).simplify(result.compiler),
-      new TypeMask.nonNullSubtype(a.rawType));
+    Expect.equals(
+        convert(singleton(b).union(singleton(d))).simplify(result.compiler),
+        new TypeMask.nonNullSubtype(a.rawType));
+  });
 }
 
 testSelectors() {
@@ -1463,45 +1524,46 @@ testSelectors() {
         new Z().foo();
       }
       """;
-  AnalysisResult result = analyze(source);
+  return analyze(source).then((result) {
 
-  inferredType(Selector selector) {
-    return result.compiler.typesTask.concreteTypesInferrer
-        .getTypeOfSelector(selector);
-  }
+    inferredType(Selector selector) {
+      return result.compiler.typesTask.concreteTypesInferrer
+          .getTypeOfSelector(selector);
+    }
 
-  ClassElement abc = findElement(result.compiler, 'ABC');
-  ClassElement bc = findElement(result.compiler, 'BC');
-  ClassElement a = findElement(result.compiler, 'A');
-  ClassElement b = findElement(result.compiler, 'B');
-  ClassElement c = findElement(result.compiler, 'C');
-  ClassElement xy = findElement(result.compiler, 'XY');
-  ClassElement x = findElement(result.compiler, 'X');
-  ClassElement y = findElement(result.compiler, 'Y');
-  ClassElement z = findElement(result.compiler, 'Z');
+    ClassElement abc = findElement(result.compiler, 'ABC');
+    ClassElement bc = findElement(result.compiler, 'BC');
+    ClassElement a = findElement(result.compiler, 'A');
+    ClassElement b = findElement(result.compiler, 'B');
+    ClassElement c = findElement(result.compiler, 'C');
+    ClassElement xy = findElement(result.compiler, 'XY');
+    ClassElement x = findElement(result.compiler, 'X');
+    ClassElement y = findElement(result.compiler, 'Y');
+    ClassElement z = findElement(result.compiler, 'Z');
 
-  Selector foo = new Selector.call(buildSourceString("foo"), null, 0);
+    Selector foo = new Selector.call(buildSourceString("foo"), null, 0);
 
-  Expect.equals(
-      inferredType(foo).simplify(result.compiler),
-      new TypeMask.nonNullSubclass(abc.rawType));
-  Expect.equals(
-      inferredType(new TypedSelector.subclass(x.rawType, foo)),
-      new TypeMask.nonNullExact(b.rawType));
-  Expect.equals(
-      inferredType(new TypedSelector.subclass(y.rawType, foo)),
-      new TypeMask.nonNullExact(c.rawType));
-  Expect.equals(
-      inferredType(new TypedSelector.subclass(z.rawType, foo)),
-      new TypeMask.nonNullExact(a.rawType));
-  Expect.equals(
-      inferredType(new TypedSelector.subclass(
-          xy.rawType, foo)).simplify(result.compiler),
-      new TypeMask.nonNullSubclass(bc.rawType));
+    Expect.equals(
+        inferredType(foo).simplify(result.compiler),
+        new TypeMask.nonNullSubclass(abc.rawType));
+    Expect.equals(
+        inferredType(new TypedSelector.subclass(x.rawType, foo)),
+        new TypeMask.nonNullExact(b.rawType));
+    Expect.equals(
+        inferredType(new TypedSelector.subclass(y.rawType, foo)),
+        new TypeMask.nonNullExact(c.rawType));
+    Expect.equals(
+        inferredType(new TypedSelector.subclass(z.rawType, foo)),
+        new TypeMask.nonNullExact(a.rawType));
+    Expect.equals(
+        inferredType(new TypedSelector.subclass(
+            xy.rawType, foo)).simplify(result.compiler),
+        new TypeMask.nonNullSubclass(bc.rawType));
 
-  Selector bar = new Selector.call(buildSourceString("bar"), null, 0);
+    Selector bar = new Selector.call(buildSourceString("bar"), null, 0);
 
-  Expect.isNull(inferredType(bar));
+    Expect.isNull(inferredType(bar));
+  });
 }
 
 testMixins() {
@@ -1523,11 +1585,12 @@ testMixins() {
         x; y; z; w;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('x', [result.string]);
-  result.checkNodeHasType('y', [result.string]);
-  result.checkNodeHasType('z', [result.int]);
-  result.checkNodeHasType('w', [result.int]);
+  return analyze(source).then((result) {
+    result.checkNodeHasType('x', [result.string]);
+    result.checkNodeHasType('y', [result.string]);
+    result.checkNodeHasType('z', [result.int]);
+    result.checkNodeHasType('w', [result.int]);
+  });
 }
 
 testClosures() {
@@ -1549,10 +1612,11 @@ testClosures() {
         a; b; f;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('a', [result.int, result.string]);
-  result.checkNodeHasType('f', [result.functionType]);
-  result.checkNodeHasUnknownType('b');
+  return analyze(source).then((AnalysisResult result) {
+    result.checkNodeHasType('a', [result.int, result.string]);
+    result.checkNodeHasType('f', [result.functionType]);
+    result.checkNodeHasUnknownType('b');
+  });
 }
 
 testNestedFunctions() {
@@ -1574,69 +1638,72 @@ testNestedFunctions() {
         a; b; f;
       }
       """;
-  AnalysisResult result = analyze(source);
-  result.checkNodeHasType('a', [result.int, result.string]);
-  result.checkNodeHasType('f', [result.functionType]);
-  result.checkNodeHasUnknownType('b');
+  return analyze(source).then((AnalysisResult result) {
+    result.checkNodeHasType('a', [result.int, result.string]);
+    result.checkNodeHasType('f', [result.functionType]);
+    result.checkNodeHasUnknownType('b');
+  });
 }
 
 void main() {
-  testDynamicBackDoor();
-  testVariableDeclaration();
-  testLiterals();
-  testRedefinition();
-  testIfThenElse();
-  testTernaryIf();
-  testWhile();
-  testDoWhile();
-  testFor1();
-  testFor2();
-  testFor3();
-  testForIn();
-  testToplevelVariable();
-  testNonRecusiveFunction();
-  testRecusiveFunction();
-  testMutuallyRecusiveFunction();
-  testSimpleSend();
-  // testSendToClosureField();  // closures are not yet supported
-  testSendToThis1();
-  testSendToThis2();
-  testSendToThis3();
-  testConstructor();
-  testGetters();
-  testSetters();
-  testOptionalNamedParameters();
-  testOptionalPositionalParameters();
-  testListLiterals();
-  testMapLiterals();
-  testReturn();
-  // testNoReturn(); // right now we infer the empty type instead of null
-  testArithmeticOperators();
-  testBooleanOperators();
-  testBooleanOperatorsShortCirtcuit();
-  testOperators();
-  testCompoundOperators1();
-  testCompoundOperators2();
-  testSetIndexOperator();
-  testInequality();
-  testFieldInitialization1();
-  testFieldInitialization2();
-  testFieldInitialization3();
-  testSendWithWrongArity();
-  testBigTypesWidening1();
-  testBigTypesWidening2();
-  testDynamicIsAbsorbing();
-  testLists();
-  testListWithCapacity();
-  testEmptyList();
-  testJsCall();
-  testJsCallAugmentsSeenClasses();
-  testIsCheck();
-  testSeenClasses();
-  testIntDoubleNum();
-  testConcreteTypeToTypeMask();
-  testSelectors();
-  testMixins();
-  testClosures();
-  testNestedFunctions();
+  asyncTest(() => Future.forEach([
+    testDynamicBackDoor,
+    testVariableDeclaration,
+    testLiterals,
+    testRedefinition,
+    testIfThenElse,
+    testTernaryIf,
+    testWhile,
+    testDoWhile,
+    testFor1,
+    testFor2,
+    testFor3,
+    testForIn,
+    testToplevelVariable,
+    testNonRecusiveFunction,
+    testRecusiveFunction,
+    testMutuallyRecusiveFunction,
+    testSimpleSend,
+    // testSendToClosureField,  // closures are not yet supported
+    testSendToThis1,
+    testSendToThis2,
+    testSendToThis3,
+    testConstructor,
+    testGetters,
+    testSetters,
+    testOptionalNamedParameters,
+    testOptionalPositionalParameters,
+    testListLiterals,
+    testMapLiterals,
+    testReturn,
+    // testNoReturn, // right now we infer the empty type instead of null
+    testArithmeticOperators,
+    testBooleanOperators,
+    testBooleanOperatorsShortCirtcuit,
+    testOperators,
+    testCompoundOperators1,
+    testCompoundOperators2,
+    testSetIndexOperator,
+    testInequality,
+    testFieldInitialization1,
+    testFieldInitialization2,
+    testFieldInitialization3,
+    testSendWithWrongArity,
+    testBigTypesWidening1,
+    testBigTypesWidening2,
+    testDynamicIsAbsorbing,
+    testLists,
+    testListWithCapacity,
+    testEmptyList,
+    testJsCall,
+    testJsCallAugmentsSeenClasses,
+    testIsCheck,
+    testSeenClasses,
+    testIntDoubleNum,
+    testConcreteTypeToTypeMask,
+    testSelectors,
+    testMixins,
+    testClosures,
+    testNestedFunctions,
+  ], (f) => f()));
 }
diff --git a/tests/compiler/dart2js/dart_backend_test.dart b/tests/compiler/dart2js/dart_backend_test.dart
index 2afbe17d59d..608ec55b0b9 100644
--- a/tests/compiler/dart2js/dart_backend_test.dart
+++ b/tests/compiler/dart2js/dart_backend_test.dart
@@ -4,6 +4,7 @@
 
 import "package:expect/expect.dart";
 import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'parser_helper.dart';
 import 'mock_compiler.dart';
 import '../../../sdk/lib/_internal/compiler/compiler.dart';
@@ -129,13 +130,13 @@ testDart2DartWithLibrary(
   if (minify) options.add('--minify');
   if (stripTypes) options.add('--force-strip=types');
 
-  compile(
+  asyncTest(() => compile(
       scriptUri,
       fileUri('libraryRoot/'),
       fileUri('packageRoot/'),
       provider,
       handler,
-      options).then(continuation);
+      options).then(continuation));
 }
 
 testSimpleFileUnparse() {
diff --git a/tests/compiler/dart2js/dead_bailout_target_test.dart b/tests/compiler/dart2js/dead_bailout_target_test.dart
index 5e7cb911885..5c369b2e16b 100644
--- a/tests/compiler/dart2js/dead_bailout_target_test.dart
+++ b/tests/compiler/dart2js/dead_bailout_target_test.dart
@@ -6,6 +6,7 @@
 // instruction gets removed from the graph when it's not used.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 String TEST = r'''
@@ -32,7 +33,6 @@ foo(a) {
 
 main() {
   String generated = compile(TEST, entry: 'foo');
-
   // Check that we only have one bailout call. The second bailout call
   // is dead code because we know [:a.length:] is an int.
   checkNumberOfMatches(new RegExp('bailout').allMatches(generated).iterator, 1);
@@ -49,20 +49,20 @@ main() {
     Expect.isTrue(!generated.contains('getInterceptor'));
   }
 
-  generated = compileAll(TEST);
-  
-  // Check that the foo bailout method is generated.
-  checkNumberOfMatches(
-      new RegExp('foo\\\$bailout').allMatches(generated).iterator, 2);
+  asyncTest(() => compileAll(TEST).then((generated) {
+    // Check that the foo bailout method is generated.
+    checkNumberOfMatches(
+        new RegExp('foo\\\$bailout').allMatches(generated).iterator, 2);
 
-  // Check that it's the only bailout method.
-  checkNumberOfMatches(new RegExp('bailout').allMatches(generated).iterator, 2);
+    // Check that it's the only bailout method.
+    checkNumberOfMatches(new RegExp('bailout').allMatches(generated).iterator, 2);
 
-  // Check that the bailout method has a case 2 for the state, which
-  // is the second bailout in foo.
-  Expect.isTrue(generated.contains('case 2:'));
+    // Check that the bailout method has a case 2 for the state, which
+    // is the second bailout in foo.
+    Expect.isTrue(generated.contains('case 2:'));
 
-  // Finally, make sure that the reason foo does not contain
-  // 'getInterceptor' is not because the compiler renamed it.
-  Expect.isTrue(generated.contains('getInterceptor'));
+    // Finally, make sure that the reason foo does not contain
+    // 'getInterceptor' is not because the compiler renamed it.
+    Expect.isTrue(generated.contains('getInterceptor'));
+  }));
 }
diff --git a/tests/compiler/dart2js/dead_code_test.dart b/tests/compiler/dart2js/dead_code_test.dart
index 993d7e9505a..e4096c0073d 100644
--- a/tests/compiler/dart2js/dead_code_test.dart
+++ b/tests/compiler/dart2js/dead_code_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 String TEST = r'''
@@ -16,6 +17,7 @@ foo(a) {
 ''';
 
 main() {
-  String generated = compileAll(TEST);
-  Expect.isFalse(generated.contains('return 42'), 'dead code not eliminated');
+  asyncTest(() => compileAll(TEST).then((generated) {
+    Expect.isFalse(generated.contains('return 42'), 'dead code not eliminated');
+  }));
 }
diff --git a/tests/compiler/dart2js/deferred_load_graph_segmentation_test.dart b/tests/compiler/dart2js/deferred_load_graph_segmentation_test.dart
index b6b10651dd2..31ff16da7f8 100644
--- a/tests/compiler/dart2js/deferred_load_graph_segmentation_test.dart
+++ b/tests/compiler/dart2js/deferred_load_graph_segmentation_test.dart
@@ -7,6 +7,7 @@
 // much be included in the initial download (loaded eagerly).
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_source_file_helper.dart';
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
@@ -17,8 +18,7 @@ void main() {
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   var handler = new FormattingDiagnosticHandler(provider);
 
   Compiler compiler = new Compiler(provider.readStringFromUri,
@@ -27,26 +27,27 @@ void main() {
                                    libraryRoot,
                                    packageRoot,
                                    ['--analyze-only']);
-  compiler.run(Uri.parse('memory:main.dart'));
-  var main = compiler.mainApp.find(dart2js.Compiler.MAIN);
-  Expect.isNotNull(main, 'Could not find "main"');
-  compiler.deferredLoadTask.onResolutionComplete(main);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    var main = compiler.mainApp.find(dart2js.Compiler.MAIN);
+    Expect.isNotNull(main, 'Could not find "main"');
+    compiler.deferredLoadTask.onResolutionComplete(main);
 
-  var deferredClasses =
-      compiler.deferredLoadTask.allDeferredElements.where((e) => e.isClass())
-      .toSet();
+    var deferredClasses =
+        compiler.deferredLoadTask.allDeferredElements.where((e) => e.isClass())
+        .toSet();
 
-  var dateTime =
-      deferredClasses
-          .where((e) => e.name.slowToString() == 'DateTime').single;
+    var dateTime =
+        deferredClasses
+            .where((e) => e.name.slowToString() == 'DateTime').single;
 
-  var myClass =
-      deferredClasses.where((e) => e.name.slowToString() == 'MyClass').single;
+    var myClass =
+        deferredClasses.where((e) => e.name.slowToString() == 'MyClass').single;
 
-  var deferredLibrary = compiler.libraries['memory:deferred.dart'];
+    var deferredLibrary = compiler.libraries['memory:deferred.dart'];
 
-  Expect.equals(deferredLibrary, myClass.getLibrary());
-  Expect.equals(compiler.coreLibrary, dateTime.declaration.getLibrary());
+    Expect.equals(deferredLibrary, myClass.getLibrary());
+    Expect.equals(compiler.coreLibrary, dateTime.declaration.getLibrary());
+  }));
 }
 
 const Map MEMORY_SOURCE_FILES = const {
diff --git a/tests/compiler/dart2js/diagnose_ambiguous_test.dart b/tests/compiler/dart2js/diagnose_ambiguous_test.dart
index 70d2fb48aec..e026f90da91 100644
--- a/tests/compiler/dart2js/diagnose_ambiguous_test.dart
+++ b/tests/compiler/dart2js/diagnose_ambiguous_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_source_file_helper.dart';
 
 import '../../../sdk/lib/_internal/compiler/compiler.dart'
@@ -15,8 +16,7 @@ main() {
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   var diagnostics = [];
   void diagnosticHandler(Uri uri, int begin, int end,
                          String message, Diagnostic kind) {
@@ -32,28 +32,30 @@ main() {
                                    libraryRoot,
                                    packageRoot,
                                    ['--analyze-only']);
-  compiler.run(Uri.parse('memory:main.dart'));
-  diagnostics.sort();
-  var expected = [
-      'memory:exporter.dart:43:47:Info: "function(hest)" is defined here.:info',
-      'memory:library.dart:14:19:Info: "class(Fisk)" is (re)exported by '
-      'multiple libraries.:info',
-      'memory:library.dart:30:34:Info: "function(fisk)" is (re)exported by '
-      'multiple libraries.:info',
-      'memory:library.dart:41:45:Info: "function(hest)" is defined here.'
-      ':info',
-      'memory:main.dart:0:22:Info: "class(Fisk)" is imported here.:info',
-      'memory:main.dart:0:22:Info: "function(fisk)" is imported here.:info',
-      'memory:main.dart:0:22:Info: "function(hest)" is imported here.:info',
-      'memory:main.dart:23:46:Info: "class(Fisk)" is imported here.:info',
-      'memory:main.dart:23:46:Info: "function(fisk)" is imported here.:info',
-      'memory:main.dart:23:46:Info: "function(hest)" is imported here.:info',
-      'memory:main.dart:59:63:Warning: Duplicate import of "Fisk".:warning',
-      'memory:main.dart:76:80:Error: Duplicate import of "fisk".:error',
-      'memory:main.dart:86:90:Error: Duplicate import of "hest".:error'
-  ];
-  Expect.listEquals(expected, diagnostics);
-  Expect.isTrue(compiler.compilationFailed);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    diagnostics.sort();
+    var expected = [
+        'memory:exporter.dart:43:47:Info: "function(hest)" is defined here.'
+        ':info',
+        'memory:library.dart:14:19:Info: "class(Fisk)" is (re)exported by '
+        'multiple libraries.:info',
+        'memory:library.dart:30:34:Info: "function(fisk)" is (re)exported by '
+        'multiple libraries.:info',
+        'memory:library.dart:41:45:Info: "function(hest)" is defined here.'
+        ':info',
+        'memory:main.dart:0:22:Info: "class(Fisk)" is imported here.:info',
+        'memory:main.dart:0:22:Info: "function(fisk)" is imported here.:info',
+        'memory:main.dart:0:22:Info: "function(hest)" is imported here.:info',
+        'memory:main.dart:23:46:Info: "class(Fisk)" is imported here.:info',
+        'memory:main.dart:23:46:Info: "function(fisk)" is imported here.:info',
+        'memory:main.dart:23:46:Info: "function(hest)" is imported here.:info',
+        'memory:main.dart:59:63:Warning: Duplicate import of "Fisk".:warning',
+        'memory:main.dart:76:80:Error: Duplicate import of "fisk".:error',
+        'memory:main.dart:86:90:Error: Duplicate import of "hest".:error'
+    ];
+    Expect.listEquals(expected, diagnostics);
+    Expect.isTrue(compiler.compilationFailed);
+  }));
 }
 
 const Map MEMORY_SOURCE_FILES = const {
diff --git a/tests/compiler/dart2js/emit_const_fields_test.dart b/tests/compiler/dart2js/emit_const_fields_test.dart
index d539d896236..14385d7d7a7 100644
--- a/tests/compiler/dart2js/emit_const_fields_test.dart
+++ b/tests/compiler/dart2js/emit_const_fields_test.dart
@@ -4,6 +4,7 @@
 // Test that unused static consts are not emitted.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST_GUIDE = r"""
@@ -18,8 +19,9 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(TEST_GUIDE);
-  Expect.isTrue(generated.contains("42"));
-  Expect.isFalse(generated.contains("TITLE"));
+  asyncTest(() => compileAll(TEST_GUIDE).then((generated) {
+    Expect.isTrue(generated.contains("42"));
+    Expect.isFalse(generated.contains("TITLE"));
+  }));
 }
 
diff --git a/tests/compiler/dart2js/field_codegen_test.dart b/tests/compiler/dart2js/field_codegen_test.dart
index d9a8aec6543..eb1a6c4c3d7 100644
--- a/tests/compiler/dart2js/field_codegen_test.dart
+++ b/tests/compiler/dart2js/field_codegen_test.dart
@@ -4,6 +4,7 @@
 // Test that parameters keep their names in the output.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -20,8 +21,11 @@ main() { return x; }
 """;
 
 main() {
-  String generated = compileAll(TEST_NULL0);
-  Expect.isTrue(generated.contains("null"));
-  generated = compileAll(TEST_NULL1);
-  Expect.isTrue(generated.contains("null"));
+  asyncTest(() => compileAll(TEST_NULL0).then((generated) {
+    Expect.isTrue(generated.contains("null"));
+  }));
+
+  asyncTest(() => compileAll(TEST_NULL1).then((generated) {
+    Expect.isTrue(generated.contains("null"));
+  }));
 }
diff --git a/tests/compiler/dart2js/field_type_simple_inferer_test.dart b/tests/compiler/dart2js/field_type_simple_inferer_test.dart
index 9f43fd59b42..6fc97afeae9 100644
--- a/tests/compiler/dart2js/field_type_simple_inferer_test.dart
+++ b/tests/compiler/dart2js/field_type_simple_inferer_test.dart
@@ -2,7 +2,9 @@
 // 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.
 
+import 'dart:async';
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show TypeMask;
 
@@ -16,11 +18,12 @@ void compileAndFind(String code,
                     check(compiler, element)) {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(code, uri);
-  compiler.runCompiler(uri);
-  compiler.disableInlining = disableInlining;
-  var cls = findElement(compiler, className);
-  var member = cls.lookupMember(buildSourceString(memberName));
-  return check(compiler, member);
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    compiler.disableInlining = disableInlining;
+    var cls = findElement(compiler, className);
+    var member = cls.lookupMember(buildSourceString(memberName));
+    check(compiler, member);
+  }));
 }
 
 const String TEST_1 = r"""
diff --git a/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart b/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
index c1a784a3862..2c27c74a400 100644
--- a/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
+++ b/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
@@ -5,6 +5,7 @@
 // effects.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -24,16 +25,17 @@ main() {
 main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  String generated = compiler.assembledCode;
-  RegExp regexp = new RegExp(r"get\$foo");
-  Iterator matches = regexp.allMatches(generated).iterator;
-  checkNumberOfMatches(matches, 1);
-  var cls = findElement(compiler, 'A');
-  Expect.isNotNull(cls);
-  SourceString name = buildSourceString('foo');
-  var element = cls.lookupLocalMember(name);
-  Expect.isNotNull(element);
-  Selector selector = new Selector.getter(name, null);
-  Expect.isFalse(compiler.world.hasAnyUserDefinedGetter(selector));
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    String generated = compiler.assembledCode;
+    RegExp regexp = new RegExp(r"get\$foo");
+    Iterator matches = regexp.allMatches(generated).iterator;
+    checkNumberOfMatches(matches, 1);
+    var cls = findElement(compiler, 'A');
+    Expect.isNotNull(cls);
+    SourceString name = buildSourceString('foo');
+    var element = cls.lookupLocalMember(name);
+    Expect.isNotNull(element);
+    Selector selector = new Selector.getter(name, null);
+    Expect.isFalse(compiler.world.hasAnyUserDefinedGetter(selector));
+  }));
 }
diff --git a/tests/compiler/dart2js/gvn_test.dart b/tests/compiler/dart2js/gvn_test.dart
index 85bfad92583..150237d48eb 100644
--- a/tests/compiler/dart2js/gvn_test.dart
+++ b/tests/compiler/dart2js/gvn_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST_ONE = r"""
@@ -118,16 +119,20 @@ main() {
   generated = compile(TEST_FOUR, entry: 'foo');
   checkNumberOfMatches(new RegExp("shr").allMatches(generated).iterator, 1);
 
-  generated = compileAll(TEST_FIVE);
-  checkNumberOfMatches(
-      new RegExp("get\\\$foo").allMatches(generated).iterator, 1);
+  asyncTest(() => compileAll(TEST_FIVE).then((generated) {
+    checkNumberOfMatches(
+        new RegExp("get\\\$foo").allMatches(generated).iterator, 1);
+  }));
 
-  generated = compileAll(TEST_SIX);
-  Expect.isTrue(generated.contains('for (t1 = a.field === 54; t1;)'));
+  asyncTest(() => compileAll(TEST_SIX).then((generated) {
+    Expect.isTrue(generated.contains('for (t1 = a.field === 54; t1;)'));
+  }));
 
-  generated = compileAll(TEST_SEVEN);
-  Expect.isTrue(generated.contains('for (t1 = a.field === 54; t1;)'));
+  asyncTest(() => compileAll(TEST_SEVEN).then((generated) {
+    Expect.isTrue(generated.contains('for (t1 = a.field === 54; t1;)'));
+  }));
 
-  generated = compileAll(TEST_EIGHT);
-  Expect.isTrue(generated.contains('for (; i < t1; ++i)'));
+  asyncTest(() => compileAll(TEST_EIGHT).then((generated) {
+    Expect.isTrue(generated.contains('for (; i < t1; ++i)'));
+  }));
 }
diff --git a/tests/compiler/dart2js/import_test.dart b/tests/compiler/dart2js/import_test.dart
index 54748c43ff7..aeaa46907f1 100644
--- a/tests/compiler/dart2js/import_test.dart
+++ b/tests/compiler/dart2js/import_test.dart
@@ -8,6 +8,7 @@
 library dart2js.test.import;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_compiler.dart';
 
 const MEMORY_SOURCE_FILES = const {
@@ -30,17 +31,19 @@ main() {
 testMissingImports() {
   var collector = new DiagnosticCollector();
   var compiler = compilerFor(MEMORY_SOURCE_FILES, diagnosticHandler: collector);
-  compiler.run(Uri.parse('memory:main.dart'));
-  Expect.equals(4, collector.errors.length);
-  Expect.equals(1, collector.warnings.length);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    Expect.equals(4, collector.errors.length);
+    Expect.equals(1, collector.warnings.length);
+  }));
 }
 
 testMissingMain() {
   var collector = new DiagnosticCollector();
   var compiler = compilerFor({}, diagnosticHandler: collector);
-  compiler.run(Uri.parse('memory:missing.dart'));
-  Expect.equals(1, collector.errors.length);
-  Expect.equals(0, collector.warnings.length);
+  asyncTest(() => compiler.run(Uri.parse('memory:missing.dart')).then((_) {
+    Expect.equals(1, collector.errors.length);
+    Expect.equals(0, collector.warnings.length);
+  }));
 }
 
 void main() {
diff --git a/tests/compiler/dart2js/inferrer_factory_test.dart b/tests/compiler/dart2js/inferrer_factory_test.dart
index 7e2c9ec0fa5..a8b225c6e8f 100644
--- a/tests/compiler/dart2js/inferrer_factory_test.dart
+++ b/tests/compiler/dart2js/inferrer_factory_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST1 = r"""
@@ -22,9 +23,10 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(TEST1);
-  // Check that we're using the index operator on the object returned
-  // by the A factory.
-  Expect.isTrue(generated.contains('[0] = 42'));
+  asyncTest(() => compileAll(TEST1).then((generated) {
+    // Check that we're using the index operator on the object returned
+    // by the A factory.
+    Expect.isTrue(generated.contains('[0] = 42'));
+  }));
 }
 
diff --git a/tests/compiler/dart2js/library_load_test.dart b/tests/compiler/dart2js/library_load_test.dart
deleted file mode 100644
index 36c9adf2c05..00000000000
--- a/tests/compiler/dart2js/library_load_test.dart
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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.
-
-import "package:expect/expect.dart";
-import 'mock_compiler.dart';
-
-class ScanMockCompiler extends MockCompiler {
-  ScanMockCompiler() {
-    isolateHelperLibrary = null;
-    foreignLibrary = null;
-  }
-
-  LibraryElement scanBuiltinLibrary(String filename) {
-    return createLibrary(filename, "main(){}");
-  }
-}
-
-void main() {
-  Compiler compiler = new ScanMockCompiler();
-  Expect.equals(null, compiler.isolateHelperLibrary);
-  Expect.equals(null, compiler.foreignLibrary);
-  compiler.onLibraryLoaded(mockLibrary(compiler, "mock"),
-			    new Uri(scheme: 'dart', path: '_isolate_helper'));
-  Expect.isTrue(compiler.isolateHelperLibrary != null);
-  compiler.onLibraryLoaded(mockLibrary(compiler, "mock"),
-			    new Uri(scheme: 'dart', path: '_foreign_helper'));
-  Expect.isTrue(compiler.isolateHelperLibrary != null);
-  Expect.equals(new Uri(scheme: 'dart', path: '_isolate_helper'),
-		 compiler.isolateHelperLibrary.canonicalUri);
-  Expect.isTrue(compiler.foreignLibrary != null);
-  Expect.equals(new Uri(scheme: 'dart', path: '_foreign_helper'),
-		 compiler.foreignLibrary.canonicalUri);
-}
diff --git a/tests/compiler/dart2js/list_tracer2_test.dart b/tests/compiler/dart2js/list_tracer2_test.dart
index 0bc612631b2..cb7734d2edc 100644
--- a/tests/compiler/dart2js/list_tracer2_test.dart
+++ b/tests/compiler/dart2js/list_tracer2_test.dart
@@ -6,6 +6,7 @@
 // the presence of a fixed length list constructor call.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import
     '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show ContainerTypeMask, TypeMask;
@@ -25,14 +26,15 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkType(String name, type) {
-    var element = findElement(compiler, name);
-    ContainerTypeMask mask = typesInferrer.getTypeOfElement(element);
-    Expect.equals(type, mask.elementType.simplify(compiler), name);
-  }
+    checkType(String name, type) {
+      var element = findElement(compiler, name);
+      ContainerTypeMask mask = typesInferrer.getTypeOfElement(element);
+      Expect.equals(type, mask.elementType.simplify(compiler), name);
+    }
 
-  checkType('myList', compiler.typesTask.intType);
+    checkType('myList', compiler.typesTask.intType);
+  }));
 }
diff --git a/tests/compiler/dart2js/list_tracer_length_test.dart b/tests/compiler/dart2js/list_tracer_length_test.dart
index 2a48ef50fe6..6b039d8d35f 100644
--- a/tests/compiler/dart2js/list_tracer_length_test.dart
+++ b/tests/compiler/dart2js/list_tracer_length_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST1 = r"""
@@ -63,8 +64,9 @@ main() {
 """;
 
 void checkRangeError(String test, {bool hasRangeError}) {
-  String generated = compileAll(test);
-  Expect.equals(hasRangeError, generated.contains('ioore'));
+  asyncTest(() => compileAll(test).then((generated) {
+    Expect.equals(hasRangeError, generated.contains('ioore'));
+  }));
 }
 
 main() {
diff --git a/tests/compiler/dart2js/list_tracer_node_type_test.dart b/tests/compiler/dart2js/list_tracer_node_type_test.dart
index 93e636ed126..aa3e8593443 100644
--- a/tests/compiler/dart2js/list_tracer_node_type_test.dart
+++ b/tests/compiler/dart2js/list_tracer_node_type_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST1 = r"""
@@ -57,28 +58,34 @@ main() {
 
 
 main() {
-  String generated = compileAll(TEST1);
-  // Check that we only do a null check on the receiver for
-  // [: a[0] + 42 :]. We can do a null check because we inferred that
-  // the list is of type int or null.
-  Expect.isFalse(generated.contains('if (typeof t1'));
-  Expect.isTrue(generated.contains('if (t1 == null)'));
+  asyncTest(() => compileAll(TEST1).then((generated) {
+    // Check that we only do a null check on the receiver for
+    // [: a[0] + 42 :]. We can do a null check because we inferred that
+    // the list is of type int or null.
+    Expect.isFalse(generated.contains('if (typeof t1'));
+    Expect.isTrue(generated.contains('if (t1 == null)'));
+  }));
 
-  generated = compileAll(TEST2);
-  Expect.isFalse(generated.contains('if (typeof t1'));
-  Expect.isTrue(generated.contains('if (t1 == null)'));
+  asyncTest(() => compileAll(TEST2).then((generated) {
+    Expect.isFalse(generated.contains('if (typeof t1'));
+    Expect.isTrue(generated.contains('if (t1 == null)'));
+  }));
 
-  generated = compileAll(TEST3);
-  Expect.isFalse(generated.contains('if (typeof t1'));
-  Expect.isTrue(generated.contains('if (t1 == null)'));
+  asyncTest(() => compileAll(TEST3).then((generated) {
+    Expect.isFalse(generated.contains('if (typeof t1'));
+    Expect.isTrue(generated.contains('if (t1 == null)'));
+  }));
 
-  generated = compileAll(TEST4);
-  Expect.isFalse(generated.contains('if (typeof t1'));
-  Expect.isTrue(generated.contains('if (t1 == null)'));
+  asyncTest(() => compileAll(TEST4).then((generated) {
+    Expect.isFalse(generated.contains('if (typeof t1'));
+    Expect.isTrue(generated.contains('if (t1 == null)'));
+  }));
 
-  generated = compileAll(TEST5);
-  Expect.isFalse(generated.contains('iae'));
+  asyncTest(() => compileAll(TEST5).then((generated) {
+    Expect.isFalse(generated.contains('iae'));
+  }));
 
-  generated = compileAll(TEST6);
-  Expect.isFalse(generated.contains('iae'));
+  asyncTest(() => compileAll(TEST6).then((generated) {
+    Expect.isFalse(generated.contains('iae'));
+  }));
 }
diff --git a/tests/compiler/dart2js/list_tracer_test.dart b/tests/compiler/dart2js/list_tracer_test.dart
index c9b979123e2..936dd17667e 100644
--- a/tests/compiler/dart2js/list_tracer_test.dart
+++ b/tests/compiler/dart2js/list_tracer_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import
     '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show ContainerTypeMask, TypeMask;
@@ -189,43 +190,44 @@ void main() {
 void doTest(String allocation, {bool nullify}) {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(generateTest(allocation), uri);
-  compiler.runCompiler(uri);
-  var typesTask = compiler.typesTask;
-  var typesInferrer = typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesTask = compiler.typesTask;
+    var typesInferrer = typesTask.typesInferrer;
 
-  checkType(String name, type) {
-    var element = findElement(compiler, name);
-    ContainerTypeMask mask = typesInferrer.getTypeOfElement(element);
-    if (nullify) type = type.nullable();
-    Expect.equals(type, mask.elementType.simplify(compiler), name);
-  }
+    checkType(String name, type) {
+      var element = findElement(compiler, name);
+      ContainerTypeMask mask = typesInferrer.getTypeOfElement(element);
+      if (nullify) type = type.nullable();
+      Expect.equals(type, mask.elementType.simplify(compiler), name);
+    }
 
-  checkType('listInField', typesTask.numType);
-  checkType('listPassedToMethod', typesTask.numType);
-  checkType('listReturnedFromMethod', typesTask.numType);
-  checkType('listUsedWithCascade', typesTask.numType);
-  checkType('listUsedInClosure', typesTask.numType);
-  checkType('listPassedToSelector', typesTask.numType);
-  checkType('listReturnedFromSelector', typesTask.numType);
-  checkType('listUsedWithAddAndInsert', typesTask.numType);
-  checkType('listUsedWithConstraint', typesTask.numType);
-  checkType('listEscapingFromSetter', typesTask.numType);
-  checkType('listUsedInLocal', typesTask.numType);
-  checkType('listEscapingInSetterValue', typesTask.numType);
-  checkType('listEscapingInIndex', typesTask.numType);
-  checkType('listEscapingInIndexSet', typesTask.intType);
-  checkType('listEscapingTwiceInIndexSet', typesTask.numType);
-  checkType('listSetInNonFinalField', typesTask.numType);
-  checkType('listWithChangedLength', typesTask.intType.nullable());
+    checkType('listInField', typesTask.numType);
+    checkType('listPassedToMethod', typesTask.numType);
+    checkType('listReturnedFromMethod', typesTask.numType);
+    checkType('listUsedWithCascade', typesTask.numType);
+    checkType('listUsedInClosure', typesTask.numType);
+    checkType('listPassedToSelector', typesTask.numType);
+    checkType('listReturnedFromSelector', typesTask.numType);
+    checkType('listUsedWithAddAndInsert', typesTask.numType);
+    checkType('listUsedWithConstraint', typesTask.numType);
+    checkType('listEscapingFromSetter', typesTask.numType);
+    checkType('listUsedInLocal', typesTask.numType);
+    checkType('listEscapingInSetterValue', typesTask.numType);
+    checkType('listEscapingInIndex', typesTask.numType);
+    checkType('listEscapingInIndexSet', typesTask.intType);
+    checkType('listEscapingTwiceInIndexSet', typesTask.numType);
+    checkType('listSetInNonFinalField', typesTask.numType);
+    checkType('listWithChangedLength', typesTask.intType.nullable());
 
-  checkType('listPassedToClosure', typesTask.dynamicType);
-  checkType('listReturnedFromClosure', typesTask.dynamicType);
-  checkType('listUsedWithNonOkSelector', typesTask.dynamicType);
-  checkType('listPassedAsOptionalParameter', typesTask.dynamicType);
-  checkType('listPassedAsNamedParameter', typesTask.dynamicType);
+    checkType('listPassedToClosure', typesTask.dynamicType);
+    checkType('listReturnedFromClosure', typesTask.dynamicType);
+    checkType('listUsedWithNonOkSelector', typesTask.dynamicType);
+    checkType('listPassedAsOptionalParameter', typesTask.dynamicType);
+    checkType('listPassedAsNamedParameter', typesTask.dynamicType);
 
-  if (!allocation.contains('filled')) {
-    checkType('listUnset', new TypeMask.nonNullEmpty());
-    checkType('listOnlySetWithConstraint', new TypeMask.nonNullEmpty());
-  }
+    if (!allocation.contains('filled')) {
+      checkType('listUnset', new TypeMask.nonNullEmpty());
+      checkType('listOnlySetWithConstraint', new TypeMask.nonNullEmpty());
+    }
+  }));
 }
diff --git a/tests/compiler/dart2js/lookup_member_test.dart b/tests/compiler/dart2js/lookup_member_test.dart
index ea1d687c389..261e53cd7fe 100644
--- a/tests/compiler/dart2js/lookup_member_test.dart
+++ b/tests/compiler/dart2js/lookup_member_test.dart
@@ -1,76 +1,78 @@
-// 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.
-
-library subtype_test;
-
-import 'package:expect/expect.dart';
-import 'type_test_helper.dart';
-import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
-import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
-       show Element, ClassElement;
-
-void main() {
-  test();
-}
-
-void test() {
-  var env = new TypeEnvironment(r"""
-      class A<T> {
-        T foo;
-      }
-      class B<S> extends A<A<S>> {
-        S bar;
-      }
-      class C<U> extends B<String> with D<B<U>> {
-        U baz;
-      }
-      class D<V> {
-        V boz;
-      }
-      """);
-
-  void expect(DartType receiverType, String memberName, DartType expectedType) {
-    Member member = receiverType.lookupMember(env.sourceString(memberName));
-    Expect.isNotNull(member);
-    DartType memberType = member.computeType(env.compiler);
-    Expect.equals(expectedType, memberType,
-        'Wrong member type for $receiverType.$memberName.');
-  }
-
-  DartType int_ = env['int'];
-  DartType String_ = env['String'];
-
-  ClassElement A = env.getElement('A');
-  DartType T = A.typeVariables.head;
-  DartType A_T = A.thisType;
-  expect(A_T, 'foo', T);
-
-  DartType A_int = instantiate(A, [int_]);
-  expect(A_int, 'foo', int_);
-
-  ClassElement B = env.getElement('B');
-  DartType S = B.typeVariables.head;
-  DartType B_S = B.thisType;
-  expect(B_S, 'foo', instantiate(A, [S]));
-  expect(B_S, 'bar', S);
-
-  DartType B_int = instantiate(B, [int_]);
-  expect(B_int, 'foo', A_int);
-  expect(B_int, 'bar', int_);
-
-  ClassElement C = env.getElement('C');
-  DartType U = C.typeVariables.head;
-  DartType C_U = C.thisType;
-  expect(C_U, 'foo', instantiate(A, [String_]));
-  expect(C_U, 'bar', String_);
-  expect(C_U, 'baz', U);
-  expect(C_U, 'boz', instantiate(B, [U]));
-
-  DartType C_int = instantiate(C, [int_]);
-  expect(C_int, 'foo', instantiate(A, [String_]));
-  expect(C_int, 'bar', String_);
-  expect(C_int, 'baz', int_);
-  expect(C_int, 'boz', instantiate(B, [int_]));
-}
-
+// 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.
+
+library subtype_test;
+
+import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
+import 'type_test_helper.dart';
+import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
+import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
+       show Element, ClassElement;
+
+void main() {
+  test();
+}
+
+void test() {
+  asyncTest(() => TypeEnvironment.create(r"""
+      class A<T> {
+        T foo;
+      }
+      class B<S> extends A<A<S>> {
+        S bar;
+      }
+      class C<U> extends B<String> with D<B<U>> {
+        U baz;
+      }
+      class D<V> {
+        V boz;
+      }
+      """).then((env) {
+    void expect(DartType receiverType, String memberName,
+                DartType expectedType) {
+      Member member = receiverType.lookupMember(env.sourceString(memberName));
+      Expect.isNotNull(member);
+      DartType memberType = member.computeType(env.compiler);
+      Expect.equals(expectedType, memberType,
+          'Wrong member type for $receiverType.$memberName.');
+    }
+
+    DartType int_ = env['int'];
+    DartType String_ = env['String'];
+
+    ClassElement A = env.getElement('A');
+    DartType T = A.typeVariables.head;
+    DartType A_T = A.thisType;
+    expect(A_T, 'foo', T);
+
+    DartType A_int = instantiate(A, [int_]);
+    expect(A_int, 'foo', int_);
+
+    ClassElement B = env.getElement('B');
+    DartType S = B.typeVariables.head;
+    DartType B_S = B.thisType;
+    expect(B_S, 'foo', instantiate(A, [S]));
+    expect(B_S, 'bar', S);
+
+    DartType B_int = instantiate(B, [int_]);
+    expect(B_int, 'foo', A_int);
+    expect(B_int, 'bar', int_);
+
+    ClassElement C = env.getElement('C');
+    DartType U = C.typeVariables.head;
+    DartType C_U = C.thisType;
+    expect(C_U, 'foo', instantiate(A, [String_]));
+    expect(C_U, 'bar', String_);
+    expect(C_U, 'baz', U);
+    expect(C_U, 'boz', instantiate(B, [U]));
+
+    DartType C_int = instantiate(C, [int_]);
+    expect(C_int, 'foo', instantiate(A, [String_]));
+    expect(C_int, 'bar', String_);
+    expect(C_int, 'baz', int_);
+    expect(C_int, 'boz', instantiate(B, [int_]));
+  }));
+}
+
diff --git a/tests/compiler/dart2js/memory_compiler.dart b/tests/compiler/dart2js/memory_compiler.dart
index 04a95dfe4c8..eb5f5888688 100644
--- a/tests/compiler/dart2js/memory_compiler.dart
+++ b/tests/compiler/dart2js/memory_compiler.dart
@@ -83,8 +83,7 @@ Compiler compilerFor(Map<String,String> memorySourceFiles,
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = memorySourceFiles;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(memorySourceFiles);
   var handler =
       createDiagnosticHandler(diagnosticHandler, provider, showDiagnostics);
 
@@ -93,7 +92,7 @@ Compiler compilerFor(Map<String,String> memorySourceFiles,
     return new NullSink('$name.$extension');
   }
 
-  Compiler compiler = new Compiler(provider,
+  Compiler compiler = new Compiler(provider.readStringFromUri,
                                    outputProvider,
                                    handler,
                                    libraryRoot,
@@ -141,8 +140,7 @@ Future<MirrorSystem> mirrorSystemFor(Map<String,String> memorySourceFiles,
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = memorySourceFiles;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(memorySourceFiles);
   var handler =
       createDiagnosticHandler(diagnosticHandler, provider, showDiagnostics);
 
diff --git a/tests/compiler/dart2js/memory_source_file_helper.dart b/tests/compiler/dart2js/memory_source_file_helper.dart
index f8ecb277a63..8ebdf7d6763 100644
--- a/tests/compiler/dart2js/memory_source_file_helper.dart
+++ b/tests/compiler/dart2js/memory_source_file_helper.dart
@@ -24,14 +24,17 @@ export '../../../sdk/lib/_internal/compiler/implementation/source_file_provider.
        show SourceFileProvider, FormattingDiagnosticHandler;
 
 class MemorySourceFileProvider extends SourceFileProvider {
-  static Map MEMORY_SOURCE_FILES;
+  final Map<String, String> memorySourceFiles;
+
+  MemorySourceFileProvider(Map<String, String> this.memorySourceFiles);
+
   Future<String> readStringFromUri(Uri resourceUri) {
     if (resourceUri.scheme != 'memory') {
       return super.readStringFromUri(resourceUri);
     }
-    String source = MEMORY_SOURCE_FILES[resourceUri.path];
+    String source = memorySourceFiles[resourceUri.path];
     // TODO(ahe): Return new Future.error(...) ?
-    if (source == null) throw 'No such file $resourceUri';
+    if (source == null) return new Future.error('No such file $resourceUri');
     String resourceName = '$resourceUri';
     this.sourceFiles[resourceName] = new SourceFile(resourceName, source);
     return new Future.value(source);
diff --git a/tests/compiler/dart2js/message_kind_helper.dart b/tests/compiler/dart2js/message_kind_helper.dart
index b7163fe8369..b4c554027bb 100644
--- a/tests/compiler/dart2js/message_kind_helper.dart
+++ b/tests/compiler/dart2js/message_kind_helper.dart
@@ -5,6 +5,7 @@
 library dart2js.test.message_kind_helper;
 
 import 'package:expect/expect.dart';
+import 'dart:async';
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart' show
     Compiler,
@@ -14,7 +15,7 @@ import 'memory_compiler.dart';
 
 const String ESCAPE_REGEXP = r'[[\]{}()*+?.\\^$|]';
 
-Compiler check(MessageKind kind, Compiler cachedCompiler) {
+Future<Compiler> check(MessageKind kind, Compiler cachedCompiler) {
   Expect.isNotNull(kind.howToFix);
   Expect.isFalse(kind.examples.isEmpty);
 
@@ -33,21 +34,22 @@ Compiler check(MessageKind kind, Compiler cachedCompiler) {
         options: ['--analyze-only'],
         cachedCompiler: cachedCompiler);
 
-    compiler.run(Uri.parse('memory:main.dart'));
+    return compiler.run(Uri.parse('memory:main.dart')).then((_) {
 
-    Expect.isFalse(messages.isEmpty, 'No messages in """$example"""');
+      Expect.isFalse(messages.isEmpty, 'No messages in """$example"""');
 
-    String expectedText = !kind.hasHowToFix
-        ? kind.template : '${kind.template}\n${kind.howToFix}';
-    String pattern = expectedText.replaceAllMapped(
-        new RegExp(ESCAPE_REGEXP), (m) => '\\${m[0]}');
-    pattern = pattern.replaceAll(new RegExp(r'#\\\{[^}]*\\\}'), '.*');
+      String expectedText = !kind.hasHowToFix
+          ? kind.template : '${kind.template}\n${kind.howToFix}';
+      String pattern = expectedText.replaceAllMapped(
+          new RegExp(ESCAPE_REGEXP), (m) => '\\${m[0]}');
+      pattern = pattern.replaceAll(new RegExp(r'#\\\{[^}]*\\\}'), '.*');
 
-    for (String message in messages) {
-      Expect.isTrue(new RegExp('^$pattern\$').hasMatch(message),
-                    '"$pattern" does not match "$message"');
-    }
-    cachedCompiler = compiler;
+      for (String message in messages) {
+        Expect.isTrue(new RegExp('^$pattern\$').hasMatch(message),
+                      '"$pattern" does not match "$message"');
+      }
+      return compiler;
+    });
   }
 
   return cachedCompiler;
diff --git a/tests/compiler/dart2js/message_kind_test.dart b/tests/compiler/dart2js/message_kind_test.dart
index 55f9beda001..6610e125cbd 100644
--- a/tests/compiler/dart2js/message_kind_test.dart
+++ b/tests/compiler/dart2js/message_kind_test.dart
@@ -2,6 +2,9 @@
 // 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.
 
+import 'package:expect/expect.dart';
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart' show
     DualKind,
     MessageKind;
@@ -43,10 +46,14 @@ main() {
     }
   };
   var cachedCompiler;
-  for (String name in examples) {
+  asyncTest(() => Future.forEach(examples, (String name) {
     Stopwatch sw = new Stopwatch()..start();
-    cachedCompiler = check(kinds[name], cachedCompiler);
-    sw.stop();
-    print("Checked '$name' in ${sw.elapsedMilliseconds}ms.");
-  }
+    return check(kinds[name], cachedCompiler).
+        then((var compiler) {
+          cachedCompiler = compiler;
+          sw.stop();
+          print("Checked '$name' in ${sw.elapsedMilliseconds}ms.");
+        });
+    }
+  ));
 }
diff --git a/tests/compiler/dart2js/metadata_test.dart b/tests/compiler/dart2js/metadata_test.dart
index 0e3b20bc27a..3f8426330fd 100644
--- a/tests/compiler/dart2js/metadata_test.dart
+++ b/tests/compiler/dart2js/metadata_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -20,16 +21,14 @@ void checkPosition(Spannable spannable, Node node, String source, compiler) {
 
 void checkAnnotation(String name, String declaration,
                      {bool isTopLevelOnly: false}) {
-  var source;
-
   // Ensure that a compile-time constant can be resolved from an
   // annotation.
-  source = """const native = 'xyz';
-              @native
-              $declaration
-              main() {}""";
+  var source1 = """const native = 'xyz';
+                   @native
+                   $declaration
+                   main() {}""";
 
-  compileAndCheck(source, name, (compiler, element) {
+  compileAndCheck(source1, name, (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
     Expect.equals(1, length(element.metadata));
     PartialMetadataAnnotation annotation = element.metadata.head;
@@ -37,17 +36,17 @@ void checkAnnotation(String name, String declaration,
     Constant value = annotation.value;
     Expect.stringEquals('xyz', value.value.slowToString());
 
-    checkPosition(annotation, annotation.cachedNode, source, compiler);
+    checkPosition(annotation, annotation.cachedNode, source1, compiler);
   });
 
   // Ensure that each repeated annotation has a unique instance of
   // [MetadataAnnotation].
-  source = """const native = 'xyz';
-              @native @native
-              $declaration
-              main() {}""";
+  var source2 = """const native = 'xyz';
+                   @native @native
+                   $declaration
+                   main() {}""";
 
-  compileAndCheck(source, name, (compiler, element) {
+  compileAndCheck(source2, name, (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
     Expect.equals(2, length(element.metadata));
     PartialMetadataAnnotation annotation1 = element.metadata.head;
@@ -63,22 +62,22 @@ void checkAnnotation(String name, String declaration,
     Expect.stringEquals('xyz', value1.value.slowToString());
     Expect.stringEquals('xyz', value2.value.slowToString());
 
-    checkPosition(annotation1, annotation1.cachedNode, source, compiler);
-    checkPosition(annotation2, annotation2.cachedNode, source, compiler);
+    checkPosition(annotation1, annotation1.cachedNode, source2, compiler);
+    checkPosition(annotation2, annotation2.cachedNode, source2, compiler);
   });
 
   if (isTopLevelOnly) return;
 
   // Ensure that a compile-time constant can be resolved from an
   // annotation.
-  source = """const native = 'xyz';
-              class Foo {
-                @native
-                $declaration
-              }
-              main() {}""";
+  var source3 = """const native = 'xyz';
+                   class Foo {
+                     @native
+                     $declaration
+                   }
+                   main() {}""";
 
-  compileAndCheck(source, 'Foo', (compiler, element) {
+  compileAndCheck(source3, 'Foo', (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
     Expect.equals(0, length(element.metadata));
     element.ensureResolved(compiler);
@@ -90,19 +89,19 @@ void checkAnnotation(String name, String declaration,
     Constant value = annotation.value;
     Expect.stringEquals('xyz', value.value.slowToString());
 
-    checkPosition(annotation, annotation.cachedNode, source, compiler);
+    checkPosition(annotation, annotation.cachedNode, source3, compiler);
   });
 
   // Ensure that each repeated annotation has a unique instance of
   // [MetadataAnnotation].
-  source = """const native = 'xyz';
-              class Foo {
-                @native @native
-                $declaration
-              }
-              main() {}""";
+  var source4 = """const native = 'xyz';
+                   class Foo {
+                     @native @native
+                     $declaration
+                   }
+                   main() {}""";
 
-  compileAndCheck(source, 'Foo', (compiler, element) {
+  compileAndCheck(source4, 'Foo', (compiler, element) {
     compiler.enqueuer.resolution.queueIsClosed = false;
     Expect.equals(0, length(element.metadata));
     element.ensureResolved(compiler);
@@ -122,8 +121,8 @@ void checkAnnotation(String name, String declaration,
     Expect.stringEquals('xyz', value1.value.slowToString());
     Expect.stringEquals('xyz', value2.value.slowToString());
 
-    checkPosition(annotation1, annotation1.cachedNode, source, compiler);
-    checkPosition(annotation1, annotation2.cachedNode, source, compiler);
+    checkPosition(annotation1, annotation1.cachedNode, source4, compiler);
+    checkPosition(annotation1, annotation2.cachedNode, source4, compiler);
   });
 }
 
@@ -156,21 +155,23 @@ void testLibraryTags() {
     var compiler = compilerFor(source, uri)
         ..registerSource(partUri, partSource)
         ..registerSource(libUri, libSource)
-        ..registerSource(async, 'class DeferredLibrary {}')
-        ..runCompiler(uri);
-    compiler.enqueuer.resolution.queueIsClosed = false;
-    LibraryElement element = compiler.libraries['$uri'];
-    Expect.isNotNull(element, 'Cannot find $uri');
+        ..registerSource(async, 'class DeferredLibrary {}');
 
-    Link<MetadataAnnotation> metadata = extractMetadata(element);
-    Expect.equals(1, length(metadata));
+    asyncTest(() => compiler.runCompiler(uri).then((_) {
+      compiler.enqueuer.resolution.queueIsClosed = false;
+      LibraryElement element = compiler.libraries['$uri'];
+      Expect.isNotNull(element, 'Cannot find $uri');
 
-    PartialMetadataAnnotation annotation = metadata.head;
-    annotation.ensureResolved(compiler);
-    Constant value = annotation.value;
-    Expect.stringEquals('xyz', value.value.slowToString());
+      Link<MetadataAnnotation> metadata = extractMetadata(element);
+      Expect.equals(1, length(metadata));
 
-    checkPosition(annotation, annotation.cachedNode, source, compiler);
+      PartialMetadataAnnotation annotation = metadata.head;
+      annotation.ensureResolved(compiler);
+      Constant value = annotation.value;
+      Expect.stringEquals('xyz', value.value.slowToString());
+
+      checkPosition(annotation, annotation.cachedNode, source, compiler);
+    }));
   }
 
   var source;
diff --git a/tests/compiler/dart2js/mirror_helper_rename_test.dart b/tests/compiler/dart2js/mirror_helper_rename_test.dart
index 67f1a956312..9b82355e997 100644
--- a/tests/compiler/dart2js/mirror_helper_rename_test.dart
+++ b/tests/compiler/dart2js/mirror_helper_rename_test.dart
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'memory_compiler.dart' show compilerFor;
 import '../../../sdk/lib/_internal/compiler/implementation/apiimpl.dart' show
     Compiler;
@@ -26,7 +28,7 @@ main() {
   testWithoutMirrorHelperLibrary(minify: false);
 }
 
-Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
+Future<Compiler> runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   List<String> options = ['--output-type=dart'];
   if (minify) {
     options.add('--minify');
@@ -34,58 +36,59 @@ Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   Compiler compiler = compilerFor(MEMORY_SOURCE_FILES, options: options);
   DartBackend backend = compiler.backend;
   backend.useMirrorHelperLibrary = useMirrorHelperLibrary;
-  compiler.runCompiler(Uri.parse('memory:main.dart'));
-  return compiler;
+  return
+      compiler.runCompiler(Uri.parse('memory:main.dart')).then((_) => compiler);
 }
 
 void testWithMirrorHelperLibrary({bool minify}) {
-  Compiler compiler = runCompiler(useMirrorHelperLibrary: true, minify: minify);
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: true, minify: minify).
+      then((Compiler compiler) {
+    DartBackend backend = compiler.backend;
+    MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
+    Map<Node, String> renames = backend.renames;
+    Map<String, SourceString> symbols = mirrorRenamer.symbols;
 
-  DartBackend backend = compiler.backend;
-  MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
-  Map<Node, String> renames = backend.renames;
-  Map<String, SourceString> symbols = mirrorRenamer.symbols;
+    Expect.isFalse(null == backend.mirrorHelperLibrary);
+    Expect.isFalse(null == backend.mirrorHelperGetNameFunction);
 
-  Expect.isFalse(null == backend.mirrorHelperLibrary);
-  Expect.isFalse(null == backend.mirrorHelperGetNameFunction);
-
-  for (Node n in renames.keys) {
-    if (symbols.containsKey(renames[n])) {
-      if(n.toString() == 'getName') {
-        Expect.equals(
-            const SourceString(MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION),
-            symbols[renames[n]]);
-      } else {
-        Expect.equals(n.toString(), symbols[renames[n]].stringValue);
+    for (Node n in renames.keys) {
+      if (symbols.containsKey(renames[n])) {
+        if(n.toString() == 'getName') {
+          Expect.equals(
+              const SourceString(MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION),
+              symbols[renames[n]]);
+        } else {
+          Expect.equals(n.toString(), symbols[renames[n]].stringValue);
+        }
       }
     }
-  }
 
-  String output = compiler.assembledCode;
-  String getNameMatch = MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION;
-  Iterable i = getNameMatch.allMatches(output);
+    String output = compiler.assembledCode;
+    String getNameMatch = MirrorRenamer.MIRROR_HELPER_GET_NAME_FUNCTION;
+    Iterable i = getNameMatch.allMatches(output);
 
+    if (minify) {
+      Expect.equals(0, i.length);
+    } else {
+      // Appears twice in code (defined & called).
+      Expect.equals(2, i.length);
+    }
 
-  if (minify) {
-    Expect.equals(0, i.length);
-  } else {
-    // Appears twice in code (defined & called).
-    Expect.equals(2, i.length);
-  }
-
-  String mapMatch = 'const<String,SourceString>';
-  i = mapMatch.allMatches(output);
-  Expect.equals(1, i.length);
+    String mapMatch = 'const<String,SourceString>';
+    i = mapMatch.allMatches(output);
+    Expect.equals(1, i.length);
+  }));
 }
 
 void testWithoutMirrorHelperLibrary({bool minify}) {
-  Compiler compiler =
-      runCompiler(useMirrorHelperLibrary: false, minify: minify);
-  DartBackend backend = compiler.backend;
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: false, minify: minify).
+      then((Compiler compiler) {
+    DartBackend backend = compiler.backend;
 
-  Expect.equals(null, backend.mirrorHelperLibrary);
-  Expect.equals(null, backend.mirrorHelperGetNameFunction);
-  Expect.equals(null, backend.mirrorRenamer);
+    Expect.equals(null, backend.mirrorHelperLibrary);
+    Expect.equals(null, backend.mirrorHelperGetNameFunction);
+    Expect.equals(null, backend.mirrorRenamer);
+  }));
 }
 
 const MEMORY_SOURCE_FILES = const <String, String> {
diff --git a/tests/compiler/dart2js/mirror_helper_test.dart b/tests/compiler/dart2js/mirror_helper_test.dart
index ba3b9aff64c..b2f2b297df1 100644
--- a/tests/compiler/dart2js/mirror_helper_test.dart
+++ b/tests/compiler/dart2js/mirror_helper_test.dart
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'memory_compiler.dart' show compilerFor;
 import '../../../sdk/lib/_internal/compiler/implementation/apiimpl.dart' show
     Compiler;
@@ -35,7 +37,7 @@ main() {
   testWithoutMirrorRenaming(minify: false);
 }
 
-Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
+Future<Compiler> runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   List<String> options = ['--output-type=dart'];
   if (minify) {
     options.add('--minify');
@@ -43,42 +45,45 @@ Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   Compiler compiler = compilerFor(MEMORY_SOURCE_FILES, options: options);
   DartBackend backend = compiler.backend;
   backend.useMirrorHelperLibrary = useMirrorHelperLibrary;
-  compiler.runCompiler(Uri.parse('memory:main.dart'));
-  return compiler;
+  return
+      compiler.runCompiler(Uri.parse('memory:main.dart')).then((_) => compiler);
 }
 
 void testWithMirrorRenaming({bool minify}) {
-  Compiler compiler = runCompiler(useMirrorHelperLibrary: true, minify: minify);
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: true, minify: minify).
+      then((Compiler compiler) {
 
-  DartBackend backend = compiler.backend;
-  MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
-  Map<Node, String> renames = backend.renames;
-  Map<LibraryElement, String> imports = backend.imports;
+    DartBackend backend = compiler.backend;
+    MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
+    Map<Node, String> renames = backend.renames;
+    Map<LibraryElement, String> imports = backend.imports;
 
-  Node getNameFunctionNode =
-      backend.memberNodes.values.first.first.body.statements.nodes.head;
+    Node getNameFunctionNode =
+        backend.memberNodes.values.first.first.body.statements.nodes.head;
 
-  Expect.equals(renames[mirrorRenamer.mirrorHelperGetNameFunctionNode.name],
-                renames[getNameFunctionNode.expression.selector]);
-  Expect.equals("",
-                renames[getNameFunctionNode.expression.receiver]);
-  Expect.equals(1, imports.keys.length);
+    Expect.equals(renames[mirrorRenamer.mirrorHelperGetNameFunctionNode.name],
+                  renames[getNameFunctionNode.expression.selector]);
+    Expect.equals("",
+                  renames[getNameFunctionNode.expression.receiver]);
+    Expect.equals(1, imports.keys.length);
+  }));
 }
 
 void testWithoutMirrorRenaming({bool minify}) {
-  Compiler compiler =
-      runCompiler(useMirrorHelperLibrary: false, minify: minify);
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: false, minify: minify).
+      then((Compiler compiler) {
 
-  DartBackend backend = compiler.backend;
-  Map<Node, String> renames = backend.renames;
-  Map<LibraryElement, String> imports = backend.imports;
+    DartBackend backend = compiler.backend;
+    Map<Node, String> renames = backend.renames;
+    Map<LibraryElement, String> imports = backend.imports;
 
-  Node getNameFunctionNode =
-      backend.memberNodes.values.first.first.body.statements.nodes.head;
+    Node getNameFunctionNode =
+        backend.memberNodes.values.first.first.body.statements.nodes.head;
 
-  Expect.isFalse(renames.containsKey(getNameFunctionNode.expression.selector));
-  Expect.isFalse(renames.containsKey(getNameFunctionNode.expression.receiver));
-  Expect.equals(1, imports.keys.length);
+    Expect.isFalse(renames.containsKey(getNameFunctionNode.expression.selector));
+    Expect.isFalse(renames.containsKey(getNameFunctionNode.expression.receiver));
+    Expect.equals(1, imports.keys.length);
+  }));
 }
 
 const MEMORY_SOURCE_FILES = const <String, String> {
diff --git a/tests/compiler/dart2js/mirror_helper_unique_minification_test.dart b/tests/compiler/dart2js/mirror_helper_unique_minification_test.dart
index c1206fcbe3f..490aad35a78 100644
--- a/tests/compiler/dart2js/mirror_helper_unique_minification_test.dart
+++ b/tests/compiler/dart2js/mirror_helper_unique_minification_test.dart
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'memory_compiler.dart' show compilerFor;
 import '../../../sdk/lib/_internal/compiler/implementation/apiimpl.dart' show
     Compiler;
@@ -20,7 +22,7 @@ main() {
   testNoUniqueMinification();
 }
 
-Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
+Future<Compiler> runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   List<String> options = ['--output-type=dart'];
   if (minify) {
     options.add('--minify');
@@ -28,41 +30,46 @@ Compiler runCompiler({useMirrorHelperLibrary: false, minify: false}) {
   Compiler compiler = compilerFor(MEMORY_SOURCE_FILES, options: options);
   DartBackend backend = compiler.backend;
   backend.useMirrorHelperLibrary = useMirrorHelperLibrary;
-  compiler.runCompiler(Uri.parse('memory:main.dart'));
-  return compiler;
+  return
+      compiler.runCompiler(Uri.parse('memory:main.dart')).then((_) => compiler);
 }
 
 void testUniqueMinification() {
-  Compiler compiler = runCompiler(useMirrorHelperLibrary: true, minify: true);
-  DartBackend backend = compiler.backend;
-  MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
-  Map<Node, String> renames = backend.renames;
-  Map<String, SourceString> symbols = mirrorRenamer.symbols;
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: true, minify: true).
+      then((Compiler compiler) {
+    DartBackend backend = compiler.backend;
+    MirrorRenamer mirrorRenamer = backend.mirrorRenamer;
+    Map<Node, String> renames = backend.renames;
+    Map<String, SourceString> symbols = mirrorRenamer.symbols;
 
-  // Check that no two different source code names get the same mangled name,
-  // with the exception of MirrorSystem.getName that gets renamed to the same
-  // mangled name as the getNameHelper from _mirror_helper.dart.
-  for (Node node in renames.keys) {
-    Identifier identifier = node.asIdentifier();
-    if (identifier != null) {
-      SourceString source = identifier.source;
-      if (mirrorRenamer.mirrorSystemGetNameNodes.first.selector == node)
-        continue;
-      if (symbols.containsKey(renames[node])) {
-        print(node);
-        Expect.equals(source, symbols[renames[node]]);
+    // Check that no two different source code names get the same mangled name,
+    // with the exception of MirrorSystem.getName that gets renamed to the same
+    // mangled name as the getNameHelper from _mirror_helper.dart.
+    for (Node node in renames.keys) {
+      Identifier identifier = node.asIdentifier();
+      if (identifier != null) {
+        SourceString source = identifier.source;
+        if (mirrorRenamer.mirrorSystemGetNameNodes.first.selector == node)
+          continue;
+        if (symbols.containsKey(renames[node])) {
+          print(node);
+          Expect.equals(source, symbols[renames[node]]);
+        }
       }
     }
-  }
+  }));
 }
 
 void testNoUniqueMinification() {
-  Compiler compiler = runCompiler(useMirrorHelperLibrary: false, minify: true);
-  DartBackend backend = compiler.backend;
-  Map<Node, String> renames = backend.renames;
+  asyncTest(() => runCompiler(useMirrorHelperLibrary: false, minify: true).
+      then((Compiler compiler) {
+    DartBackend backend = compiler.backend;
+    Map<Node, String> renames = backend.renames;
 
-  // 'Foo' appears twice and 'invocation' and 'hest' get the same mangled name.
-  Expect.equals(renames.values.toSet().length, renames.values.length - 2);
+    // 'Foo' appears twice and 'invocation' and 'hest' get the same mangled
+    // name.
+    Expect.equals(renames.values.toSet().length, renames.values.length - 2);
+  }));
 }
 
 const MEMORY_SOURCE_FILES = const <String, String> {
diff --git a/tests/compiler/dart2js/mirror_tree_shaking_test.dart b/tests/compiler/dart2js/mirror_tree_shaking_test.dart
index c3c639374ef..67717f64d02 100644
--- a/tests/compiler/dart2js/mirror_tree_shaking_test.dart
+++ b/tests/compiler/dart2js/mirror_tree_shaking_test.dart
@@ -5,6 +5,7 @@
 // Test that tree-shaking hasn't been turned off.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_source_file_helper.dart';
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
@@ -20,8 +21,7 @@ main() {
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   void diagnosticHandler(Uri uri, int begin, int end,
                          String message, Diagnostic kind) {
     if (kind == Diagnostic.VERBOSE_INFO
@@ -42,12 +42,13 @@ main() {
                                    libraryRoot,
                                    packageRoot,
                                    []);
-  compiler.run(Uri.parse('memory:main.dart'));
-  Expect.isFalse(compiler.compilationFailed);
-  Expect.isFalse(compiler.enqueuer.resolution.hasEnqueuedEverything);
-  Expect.isFalse(compiler.enqueuer.codegen.hasEnqueuedEverything);
-  Expect.isFalse(compiler.disableTypeInference);
-  Expect.isFalse(compiler.backend.hasRetainedMetadata);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    Expect.isFalse(compiler.compilationFailed);
+    Expect.isFalse(compiler.enqueuer.resolution.hasEnqueuedEverything);
+    Expect.isFalse(compiler.enqueuer.codegen.hasEnqueuedEverything);
+    Expect.isFalse(compiler.disableTypeInference);
+    Expect.isFalse(compiler.backend.hasRetainedMetadata);
+  }));
 }
 
 const Map MEMORY_SOURCE_FILES = const {
diff --git a/tests/compiler/dart2js/mirrors_lookup_test.dart b/tests/compiler/dart2js/mirrors_lookup_test.dart
index 8cda12efc12..d5ebab5aba9 100644
--- a/tests/compiler/dart2js/mirrors_lookup_test.dart
+++ b/tests/compiler/dart2js/mirrors_lookup_test.dart
@@ -5,6 +5,7 @@
 library dart2js.test.memory_source_file_helper;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_compiler.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
@@ -33,9 +34,9 @@ class Subclass<B> extends Class<B> {
 };
 
 void main() {
-  mirrorSystemFor(MEMORY_SOURCE_FILES).then(
+  asyncTest(() => mirrorSystemFor(MEMORY_SOURCE_FILES).then(
       (MirrorSystem mirrors) => test(mirrors),
-      onError: (e) => Expect.fail('$e'));
+      onError: (e) => Expect.fail('$e')));
 }
 
 void test(MirrorSystem mirrors) {
diff --git a/tests/compiler/dart2js/mirrors_metadata_test.dart b/tests/compiler/dart2js/mirrors_metadata_test.dart
index 22b0c8144ac..1e3307cc4cf 100644
--- a/tests/compiler/dart2js/mirrors_metadata_test.dart
+++ b/tests/compiler/dart2js/mirrors_metadata_test.dart
@@ -4,6 +4,7 @@
 
 import 'package:expect/expect.dart';
 import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'dart:io';
 import '../../../sdk/lib/_internal/compiler/implementation/filenames.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
@@ -14,15 +15,16 @@ import 'mock_compiler.dart';
 const String SOURCE = 'source';
 Uri SOURCE_URI = new Uri(scheme: SOURCE, path: SOURCE);
 
-MirrorSystem createMirrorSystem(String source) {
+Future<MirrorSystem> createMirrorSystem(String source) {
   MockCompiler compiler = new MockCompiler(
       analyzeOnly: true,
       analyzeAll: true,
       preserveComments: true);
-  compiler.registerSource(SOURCE_URI, source);
-  compiler.librariesToAnalyzeWhenRun = <Uri>[SOURCE_URI];
-  compiler.runCompiler(null);
-  return new Dart2JsMirrorSystem(compiler);
+    compiler.registerSource(SOURCE_URI, source);
+    compiler.librariesToAnalyzeWhenRun = <Uri>[SOURCE_URI];
+  return compiler.runCompiler(null).then((_) {
+    return new Dart2JsMirrorSystem(compiler);
+  });
 }
 
 void validateDeclarationComment(String code,
@@ -30,21 +32,22 @@ void validateDeclarationComment(String code,
                                 String trimmedText,
                                 bool isDocComment,
                                 List<String> declarationNames) {
-  MirrorSystem mirrors = createMirrorSystem(code);
-  LibraryMirror library = mirrors.libraries[SOURCE_URI];
-  Expect.isNotNull(library);
-  for (String declarationName in declarationNames) {
-    DeclarationMirror declaration = library.members[declarationName];
-    Expect.isNotNull(declaration);
-    List<InstanceMirror> metadata = declaration.metadata;
-    Expect.isNotNull(metadata);
-    Expect.equals(1, metadata.length);
-    Expect.isTrue(metadata[0] is CommentInstanceMirror);
-    CommentInstanceMirror commentMetadata = metadata[0];
-    Expect.equals(text, commentMetadata.text);
-    Expect.equals(trimmedText, commentMetadata.trimmedText);
-    Expect.equals(isDocComment, commentMetadata.isDocComment);
-  }
+  asyncTest(() => createMirrorSystem(code).then((mirrors) {
+    LibraryMirror library = mirrors.libraries[SOURCE_URI];
+    Expect.isNotNull(library);
+    for (String declarationName in declarationNames) {
+      DeclarationMirror declaration = library.members[declarationName];
+      Expect.isNotNull(declaration);
+      List<InstanceMirror> metadata = declaration.metadata;
+      Expect.isNotNull(metadata);
+      Expect.equals(1, metadata.length);
+      Expect.isTrue(metadata[0] is CommentInstanceMirror);
+      CommentInstanceMirror commentMetadata = metadata[0];
+      Expect.equals(text, commentMetadata.text);
+      Expect.equals(trimmedText, commentMetadata.trimmedText);
+      Expect.equals(isDocComment, commentMetadata.isDocComment);
+    }
+  }));
 }
 
 void testDeclarationComment(String declaration, List<String> declarationNames) {
diff --git a/tests/compiler/dart2js/mirrors_test.dart b/tests/compiler/dart2js/mirrors_test.dart
index 75aadeb55b6..7051a3b8f78 100644
--- a/tests/compiler/dart2js/mirrors_test.dart
+++ b/tests/compiler/dart2js/mirrors_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart';
@@ -48,12 +49,13 @@ main() {
   var provider = new SourceFileProvider();
   var diagnosticHandler =
         new FormattingDiagnosticHandler(provider).diagnosticHandler;
+  asyncStart();
   var result = analyze([inputUri], libUri, null,
                        provider.readStringFromUri, diagnosticHandler,
                        <String>['--preserve-comments']);
   result.then((MirrorSystem mirrors) {
     test(mirrors);
-  });
+  }).whenComplete(() => asyncEnd());
 }
 
 void test(MirrorSystem mirrors) {
diff --git a/tests/compiler/dart2js/mirrors_used_test.dart b/tests/compiler/dart2js/mirrors_used_test.dart
index 2608a311d23..4c0a807b4bf 100644
--- a/tests/compiler/dart2js/mirrors_used_test.dart
+++ b/tests/compiler/dart2js/mirrors_used_test.dart
@@ -7,6 +7,7 @@
 library dart2js.test.mirrors_used_test;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 
 import 'memory_compiler.dart' show
     compilerFor;
@@ -35,87 +36,88 @@ void expectOnlyVerboseInfo(Uri uri, int begin, int end, String message, kind) {
 void main() {
   Compiler compiler = compilerFor(
       MEMORY_SOURCE_FILES, diagnosticHandler: expectOnlyVerboseInfo);
-  compiler.runCompiler(Uri.parse('memory:main.dart'));
+  asyncTest(() => compiler.runCompiler(Uri.parse('memory:main.dart')).then((_) {
+    print('');
+    List generatedCode =
+        Elements.sortedByPosition(compiler.enqueuer.codegen.generatedCode.keys);
+    for (var element in generatedCode) {
+      print(element);
+    }
+    print('');
 
-  print('');
-  List generatedCode =
-      Elements.sortedByPosition(compiler.enqueuer.codegen.generatedCode.keys);
-  for (var element in generatedCode) {
-    print(element);
-  }
-  print('');
+    // This assertion can fail for two reasons:
+    // 1. Too many elements retained for reflection.
+    // 2. Some code was refactored, and there are more methods.
+    // Either situation could be problematic, but in situation 2, it is often
+    // acceptable to increase [expectedMethodCount] a little.
+    int expectedMethodCount = 322;
+    Expect.isTrue(
+        generatedCode.length <= expectedMethodCount,
+        'Too many compiled methods: '
+        '${generatedCode.length} > $expectedMethodCount');
 
-  // This assertion can fail for two reasons:
-  // 1. Too many elements retained for reflection.
-  // 2. Some code was refactored, and there are more methods.
-  // Either situation could be problematic, but in situation 2, it is often
-  // acceptable to increase [expectedMethodCount] a little.
-  int expectedMethodCount = 322;
-  Expect.isTrue(
-      generatedCode.length <= expectedMethodCount,
-      'Too many compiled methods: '
-      '${generatedCode.length} > $expectedMethodCount');
+    // The following names should be retained:
+    List expectedNames = [
+        'Foo', // The name of class Foo.
+        r'Foo$', // The name of class Foo's constructor.
+        'Foo_staticMethod', // The name of Foo.staticMethod.
+        r'get$field', // The (getter) name of Foo.field.
+        r'instanceMethod$0']; // The name of Foo.instanceMethod.
+    Set recordedNames = new Set()
+        ..addAll(compiler.backend.emitter.recordedMangledNames)
+        ..addAll(compiler.backend.emitter.mangledFieldNames.keys)
+        ..addAll(compiler.backend.emitter.mangledGlobalFieldNames.keys);
+    Expect.setEquals(new Set.from(expectedNames), recordedNames);
 
-  // The following names should be retained:
-  List expectedNames = [
-      'Foo', // The name of class Foo.
-      r'Foo$', // The name of class Foo's constructor.
-      'Foo_staticMethod', // The name of Foo.staticMethod.
-      r'get$field', // The (getter) name of Foo.field.
-      r'instanceMethod$0']; // The name of Foo.instanceMethod.
-  Set recordedNames = new Set()
-      ..addAll(compiler.backend.emitter.recordedMangledNames)
-      ..addAll(compiler.backend.emitter.mangledFieldNames.keys)
-      ..addAll(compiler.backend.emitter.mangledGlobalFieldNames.keys);
-  Expect.setEquals(new Set.from(expectedNames), recordedNames);
-
-  for (var library in compiler.libraries.values) {
-    library.forEachLocalMember((member) {
-      if (library == compiler.mainApp
-          && member.name == const SourceString('Foo')) {
-        Expect.isTrue(
-            compiler.backend.isNeededForReflection(member), '$member');
-        member.forEachLocalMember((classMember) {
+    for (var library in compiler.libraries.values) {
+      library.forEachLocalMember((member) {
+        if (library == compiler.mainApp
+            && member.name == const SourceString('Foo')) {
           Expect.isTrue(
-              compiler.backend.isNeededForReflection(classMember),
-              '$classMember');
-        });
-      } else {
-        Expect.isFalse(
-            compiler.backend.isNeededForReflection(member), '$member');
+              compiler.backend.isNeededForReflection(member), '$member');
+          member.forEachLocalMember((classMember) {
+            Expect.isTrue(
+                compiler.backend.isNeededForReflection(classMember),
+                '$classMember');
+          });
+        } else {
+          Expect.isFalse(
+              compiler.backend.isNeededForReflection(member), '$member');
+        }
+      });
+    }
+
+    // There should at least be three metadata constants:
+    // 1. The type literal 'Foo'.
+    // 2. The list 'const [Foo]'.
+    // 3. The constructed constant for 'MirrorsUsed'.
+    Expect.isTrue(compiler.metadataHandler.compiledConstants.length >= 3);
+
+    // Make sure that most of the metadata constants aren't included in the
+    // generated code.
+    for (Constant constant in compiler.metadataHandler.compiledConstants) {
+      if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
+        // The type literal 'Foo' is retained as a constant because it is being
+        // passed to reflectClass.
+        continue;
       }
-    });
-  }
-
-  // There should at least be three metadata constants:
-  // 1. The type literal 'Foo'.
-  // 2. The list 'const [Foo]'.
-  // 3. The constructed constant for 'MirrorsUsed'.
-  Expect.isTrue(compiler.metadataHandler.compiledConstants.length >= 3);
-
-  // Make sure that most of the metadata constants aren't included in the
-  // generated code.
-  for (Constant constant in compiler.metadataHandler.compiledConstants) {
-    if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
-      // The type literal 'Foo' is retained as a constant because it is being
-      // passed to reflectClass.
-      continue;
+      Expect.isFalse(
+          compiler.constantHandler.compiledConstants.contains(constant),
+          '$constant');
     }
-    Expect.isFalse(
-        compiler.constantHandler.compiledConstants.contains(constant),
-        '$constant');
-  }
 
-  // The type literal 'Foo' is both used as metadata, and as a plain value in
-  // the program. Make sure that it isn't duplicated.
-  int fooConstantCount = 0;
-  for (Constant constant in compiler.metadataHandler.compiledConstants) {
-    if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
-      fooConstantCount++;
+    // The type literal 'Foo' is both used as metadata, and as a plain value in
+    // the program. Make sure that it isn't duplicated.
+    int fooConstantCount = 0;
+    for (Constant constant in compiler.metadataHandler.compiledConstants) {
+      if (constant is TypeConstant && '${constant.representedType}' == 'Foo') {
+        fooConstantCount++;
+      }
     }
-  }
-  Expect.equals(
-      1, fooConstantCount, "The type literal 'Foo' is duplicated or missing.");
+    Expect.equals(
+        1, fooConstantCount,
+        "The type literal 'Foo' is duplicated or missing.");
+  }));
 }
 
 const MEMORY_SOURCE_FILES = const <String, String> {
diff --git a/tests/compiler/dart2js/missing_file_test.dart b/tests/compiler/dart2js/missing_file_test.dart
new file mode 100644
index 00000000000..349b61cb630
--- /dev/null
+++ b/tests/compiler/dart2js/missing_file_test.dart
@@ -0,0 +1,78 @@
+// 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 that the compiler can handle imports when package root has not been set.
+
+library dart2js.test.missing_file;
+
+import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
+import 'memory_source_file_helper.dart';
+
+import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
+       show NullSink;
+
+import '../../../sdk/lib/_internal/compiler/compiler.dart'
+       show DiagnosticHandler, Diagnostic;
+
+import 'dart:async';
+
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
+import '../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart';
+
+const MEMORY_SOURCE_FILES = const {
+  'main.dart': '''
+
+import 'foo.dart';
+
+main() {}
+''',
+};
+
+void runCompiler(Uri main, String expectedMessage) {
+  Uri script = currentDirectory.resolve(nativeToUriPath(Platform.script));
+  Uri libraryRoot = script.resolve('../../../sdk/');
+
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
+  var handler = new FormattingDiagnosticHandler(provider);
+  var errors = [];
+
+  void diagnosticHandler(Uri uri, int begin, int end, String message,
+                         Diagnostic kind) {
+    if (kind == Diagnostic.ERROR) {
+      errors.add(message);
+    }
+    handler(uri, begin, end, message, kind);
+  }
+
+
+  EventSink<String> outputProvider(String name, String extension) {
+    if (name != '') throw 'Attempt to output file "$name.$extension"';
+    return new NullSink('$name.$extension');
+  }
+
+  Compiler compiler = new Compiler(provider,
+                                   outputProvider,
+                                   diagnosticHandler,
+                                   libraryRoot,
+                                   null,
+                                   []);
+
+  asyncTest(() => compiler.run(main).then((_) {
+    Expect.equals(1, errors.length);
+    Expect.equals(expectedMessage,
+                  errors[0]);
+  }));
+}
+
+void main() {
+  runCompiler(Uri.parse('memory:main.dart'),
+              "Error: Can't read 'memory:foo.dart' "
+              "(No such file memory:foo.dart).");
+  runCompiler(Uri.parse('memory:foo.dart'),
+              "Error: Can't read 'memory:foo.dart' "
+              "(No such file memory:foo.dart).");
+  runCompiler(Uri.parse('dart:foo'),
+              'Error: Library not found "dart:foo".');
+}
diff --git a/tests/compiler/dart2js/mock_compiler.dart b/tests/compiler/dart2js/mock_compiler.dart
index c30295ee4b4..26a401a934d 100644
--- a/tests/compiler/dart2js/mock_compiler.dart
+++ b/tests/compiler/dart2js/mock_compiler.dart
@@ -5,6 +5,7 @@
 library mock_compiler;
 
 import "package:expect/expect.dart";
+import 'dart:async';
 import 'dart:collection';
 
 import '../../../sdk/lib/_internal/compiler/compiler.dart' as api;
@@ -238,13 +239,18 @@ class MockCompiler extends Compiler {
               analyzeOnly: analyzeOnly,
               emitJavaScript: emitJavaScript,
               preserveComments: preserveComments) {
-    coreLibrary = createLibrary("core", coreSource);
+    coreLibrary = deprecatedFutureValue(createLibrary("core", coreSource));
+
     // We need to set the assert method to avoid calls with a 'null'
     // target being interpreted as a call to assert.
-    jsHelperLibrary = createLibrary("helper", helperSource);
-    foreignLibrary = createLibrary("foreign", FOREIGN_LIBRARY);
-    interceptorsLibrary = createLibrary("interceptors", interceptorsSource);
-    isolateHelperLibrary = createLibrary("isolate_helper", isolateHelperSource);
+    jsHelperLibrary = deprecatedFutureValue(
+        createLibrary("helper", helperSource));
+    foreignLibrary = deprecatedFutureValue(
+        createLibrary("foreign", FOREIGN_LIBRARY));
+    interceptorsLibrary = deprecatedFutureValue(
+        createLibrary("interceptors", interceptorsSource));
+    isolateHelperLibrary = deprecatedFutureValue(
+        createLibrary("isolate_helper", isolateHelperSource));
 
     // Set up the library imports.
     importHelperLibrary(coreLibrary);
@@ -282,7 +288,7 @@ class MockCompiler extends Compiler {
    * Used internally to create a library from a source text. The created library
    * is fixed to export its top-level declarations.
    */
-  LibraryElement createLibrary(String name, String source) {
+  Future<LibraryElement> createLibrary(String name, String source) {
     Uri uri = new Uri(scheme: "dart", path: name);
     var script = new Script(uri, new MockFile(source));
     var library = new LibraryElementX(script);
@@ -291,7 +297,7 @@ class MockCompiler extends Compiler {
     library.setExports(library.localScope.values.toList());
     registerSource(uri, source);
     libraries.putIfAbsent(uri.toString(), () => library);
-    return library;
+    return new Future.value(library);
   }
 
   void reportWarning(Node node, var message) {
@@ -377,12 +383,14 @@ class MockCompiler extends Compiler {
     parseUnit(text, this, library, registerSource);
   }
 
-  void scanBuiltinLibraries() {
+  Future scanBuiltinLibraries() {
     // Do nothing. The mock core library is already handled in the constructor.
+    return new Future.value();
   }
 
-  LibraryElement scanBuiltinLibrary(String name) {
+  Future<LibraryElement> scanBuiltinLibrary(String name) {
     // Do nothing. The mock core library is already handled in the constructor.
+    return new Future.value();
   }
 
   Uri translateResolvedUri(LibraryElement importingLibrary,
@@ -391,10 +399,10 @@ class MockCompiler extends Compiler {
   // The mock library doesn't need any patches.
   Uri resolvePatchUri(String dartLibraryName) => null;
 
-  Script readScript(Uri uri, [Node node]) {
+  Future<Script> readScript(Uri uri, [Element element, Node node]) {
     SourceFile sourceFile = sourceFiles[uri.toString()];
     if (sourceFile == null) throw new ArgumentError(uri);
-    return new Script(uri, sourceFile);
+    return new Future.value(new Script(uri, sourceFile));
   }
 
   Element lookupElementIn(ScopeContainerElement container, name) {
diff --git a/tests/compiler/dart2js/no_constructor_body_test.dart b/tests/compiler/dart2js/no_constructor_body_test.dart
index 0a11b017392..0a3b388ce1f 100644
--- a/tests/compiler/dart2js/no_constructor_body_test.dart
+++ b/tests/compiler/dart2js/no_constructor_body_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST = r"""
@@ -17,7 +18,7 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(TEST);
-  Expect.isTrue(
-      generated.contains('A: {"": "Object;", static:'));
+  asyncTest(() => compileAll(TEST).then((generated) {
+    Expect.isTrue(generated.contains('A: {"": "Object;", static:'));
+  }));
 }
diff --git a/tests/compiler/dart2js/no_duplicate_constructor_body2_test.dart b/tests/compiler/dart2js/no_duplicate_constructor_body2_test.dart
index f2de6cf4156..a306a0cf20a 100644
--- a/tests/compiler/dart2js/no_duplicate_constructor_body2_test.dart
+++ b/tests/compiler/dart2js/no_duplicate_constructor_body2_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'compiler_helper.dart';
+import "package:async_helper/async_helper.dart";
 
 const String CODE = """
 var x = 0;
@@ -21,8 +22,9 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(CODE);
-  RegExp regexp = new RegExp(r'A\$0: function');
-  Iterator<Match> matches = regexp.allMatches(generated).iterator;
-  checkNumberOfMatches(matches, 1);
+  asyncTest(() => compileAll(CODE).then((generated) {
+    RegExp regexp = new RegExp(r'A\$0: function');
+    Iterator<Match> matches = regexp.allMatches(generated).iterator;
+    checkNumberOfMatches(matches, 1);
+  }));
 }
diff --git a/tests/compiler/dart2js/no_duplicate_constructor_body_test.dart b/tests/compiler/dart2js/no_duplicate_constructor_body_test.dart
index 3942536ef67..bad4b4c9993 100644
--- a/tests/compiler/dart2js/no_duplicate_constructor_body_test.dart
+++ b/tests/compiler/dart2js/no_duplicate_constructor_body_test.dart
@@ -2,6 +2,7 @@
 // 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.
 
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String CODE = """
@@ -15,8 +16,9 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(CODE);
-  RegExp regexp = new RegExp(r'\A: {"": "[A-za-z]+;"');
-  Iterator<Match> matches = regexp.allMatches(generated).iterator;
-  checkNumberOfMatches(matches, 1);
+  asyncTest(() => compileAll(CODE).then((generated) {
+    RegExp regexp = new RegExp(r'\A: {"": "[A-za-z]+;"');
+    Iterator<Match> matches = regexp.allMatches(generated).iterator;
+    checkNumberOfMatches(matches, 1);
+  }));
 }
diff --git a/tests/compiler/dart2js/no_duplicate_stub_test.dart b/tests/compiler/dart2js/no_duplicate_stub_test.dart
index 3213529a77f..8ace11b9c6f 100644
--- a/tests/compiler/dart2js/no_duplicate_stub_test.dart
+++ b/tests/compiler/dart2js/no_duplicate_stub_test.dart
@@ -2,6 +2,7 @@
 // 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.
 
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST = r"""
@@ -28,8 +29,9 @@ baz(a) {
 """;
 
 main() {
-  String generated = compileAll(TEST);
-  RegExp regexp = new RegExp('foo\\\$1\\\$a: function');
-  Iterator<Match> matches = regexp.allMatches(generated).iterator;
-  checkNumberOfMatches(matches, 1);
+  asyncTest(() => compileAll(TEST).then((generated) {
+    RegExp regexp = new RegExp('foo\\\$1\\\$a: function');
+    Iterator<Match> matches = regexp.allMatches(generated).iterator;
+    checkNumberOfMatches(matches, 1);
+  }));
 }
diff --git a/tests/compiler/dart2js/package_root_test.dart b/tests/compiler/dart2js/package_root_test.dart
index 62c106d693c..98b183bc514 100644
--- a/tests/compiler/dart2js/package_root_test.dart
+++ b/tests/compiler/dart2js/package_root_test.dart
@@ -7,6 +7,7 @@
 library dart2js.test.package_root;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_source_file_helper.dart';
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
@@ -33,8 +34,7 @@ void runCompiler(Uri main) {
   Uri script = currentDirectory.resolve(nativeToUriPath(Platform.script));
   Uri libraryRoot = script.resolve('../../../sdk/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   var handler = new FormattingDiagnosticHandler(provider);
   var errors = [];
 
@@ -52,18 +52,19 @@ void runCompiler(Uri main) {
     return new NullSink('$name.$extension');
   }
 
-  Compiler compiler = new Compiler(provider.readStringFromUri,
+  Compiler compiler = new Compiler(provider,
                                    outputProvider,
                                    diagnosticHandler,
                                    libraryRoot,
                                    null,
                                    []);
 
-  compiler.run(main);
-  Expect.equals(1, errors.length);
-  Expect.equals('Error: Cannot resolve "package:foo/foo.dart". '
-                'Package root has not been set.',
-                errors[0]);
+  asyncTest(() => compiler.run(main).then((_) {
+    Expect.equals(1, errors.length);
+    Expect.equals('Error: Cannot resolve "package:foo/foo.dart". '
+                  'Package root has not been set.',
+                  errors[0]);
+  }));
 }
 
 void main() {
diff --git a/tests/compiler/dart2js/part_of_test.dart b/tests/compiler/dart2js/part_of_test.dart
index 629c267013c..79eebf20270 100644
--- a/tests/compiler/dart2js/part_of_test.dart
+++ b/tests/compiler/dart2js/part_of_test.dart
@@ -5,6 +5,7 @@
 library part_of_test;
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'mock_compiler.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
     show MessageKind;
@@ -25,13 +26,16 @@ void main() {
   compiler.registerSource(libraryUri, LIBRARY_SOURCE);
   compiler.registerSource(partUri, PART_SOURCE);
 
-  compiler.libraryLoader.loadLibrary(libraryUri, null, libraryUri);
-  print('errors: ${compiler.errors}');
-  print('warnings: ${compiler.warnings}');
-  Expect.isTrue(compiler.errors.isEmpty);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.equals(MessageKind.LIBRARY_NAME_MISMATCH,
-                compiler.warnings[0].message.kind);
-  Expect.equals('foo',
-      compiler.warnings[0].message.arguments['libraryName'].toString());
+  asyncTest(() =>
+      compiler.libraryLoader.loadLibrary(libraryUri, null, libraryUri).
+      then((_) {
+    print('errors: ${compiler.errors}');
+    print('warnings: ${compiler.warnings}');
+    Expect.isTrue(compiler.errors.isEmpty);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.equals(MessageKind.LIBRARY_NAME_MISMATCH,
+                  compiler.warnings[0].message.kind);
+    Expect.equals('foo',
+        compiler.warnings[0].message.arguments['libraryName'].toString());
+  }));
 }
diff --git a/tests/compiler/dart2js/patch_test.dart b/tests/compiler/dart2js/patch_test.dart
index 779efceb5b7..98818100bff 100644
--- a/tests/compiler/dart2js/patch_test.dart
+++ b/tests/compiler/dart2js/patch_test.dart
@@ -2,7 +2,9 @@
 // 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.
 
+import 'dart:async';
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart";
@@ -10,8 +12,8 @@ import "../../../sdk/lib/_internal/compiler/implementation/util/util.dart";
 import "mock_compiler.dart";
 import "parser_helper.dart";
 
-Compiler applyPatch(String script, String patch,
-                    {bool analyzeAll: false, bool analyzeOnly: false}) {
+Future<Compiler> applyPatch(String script, String patch,
+                            {bool analyzeAll: false, bool analyzeOnly: false}) {
   String core = "$DEFAULT_CORELIB\n$script";
   MockCompiler compiler = new MockCompiler(coreSource: core,
                                            analyzeAll: analyzeAll,
@@ -19,9 +21,11 @@ Compiler applyPatch(String script, String patch,
   var uri = Uri.parse("core.dartp");
   compiler.sourceFiles[uri.toString()] = new MockFile(patch);
   var handler = new LibraryDependencyHandler(compiler);
-  compiler.patchParser.patchLibrary(handler, uri, compiler.coreLibrary);
-  handler.computeExports();
-  return compiler;
+  return compiler.patchParser.patchLibrary(handler, uri, compiler.coreLibrary)
+      .then((_) {
+    handler.computeExports();
+    return compiler;
+  });
 }
 
 void expectHasBody(compiler, Element element) {
@@ -106,22 +110,23 @@ Element ensure(compiler,
 }
 
 testPatchFunction() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       "external test();",
-      "patch test() { return 'string'; } ");
-  ensure(compiler, "test", compiler.coreLibrary.find,
-         expectIsPatched: true, checkHasBody: true);
-  ensure(compiler, "test", compiler.coreLibrary.patch.find,
-         expectIsPatch: true, checkHasBody: true);
+      "patch test() { return 'string'; } ").then((compiler) {
+    ensure(compiler, "test", compiler.coreLibrary.find,
+           expectIsPatched: true, checkHasBody: true);
+    ensure(compiler, "test", compiler.coreLibrary.patch.find,
+           expectIsPatch: true, checkHasBody: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testPatchConstructor() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         external Class();
@@ -131,34 +136,35 @@ testPatchConstructor() {
       patch class Class {
         patch Class();
       }
-      """);
-  var classOrigin = ensure(compiler, "Class", compiler.coreLibrary.find,
-                           expectIsPatched: true);
-  classOrigin.ensureResolved(compiler);
-  var classPatch = ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-                          expectIsPatch: true);
+      """).then((compiler) {
+    var classOrigin = ensure(compiler, "Class", compiler.coreLibrary.find,
+                             expectIsPatched: true);
+    classOrigin.ensureResolved(compiler);
+    var classPatch = ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+                            expectIsPatch: true);
 
-  Expect.equals(classPatch, classOrigin.patch);
-  Expect.equals(classOrigin, classPatch.origin);
+    Expect.equals(classPatch, classOrigin.patch);
+    Expect.equals(classOrigin, classPatch.origin);
 
-  var constructorOrigin = ensure(compiler, "",
-                                 (name) => classOrigin.localLookup(name),
-                                 expectIsPatched: true);
-  var constructorPatch = ensure(compiler, "",
-                                (name) => classPatch.localLookup(name),
-                                expectIsPatch: true);
+    var constructorOrigin = ensure(compiler, "",
+                                   (name) => classOrigin.localLookup(name),
+                                   expectIsPatched: true);
+    var constructorPatch = ensure(compiler, "",
+                                  (name) => classPatch.localLookup(name),
+                                  expectIsPatch: true);
 
-  Expect.equals(constructorPatch, constructorOrigin.patch);
-  Expect.equals(constructorOrigin, constructorPatch.origin);
+    Expect.equals(constructorPatch, constructorOrigin.patch);
+    Expect.equals(constructorOrigin, constructorPatch.origin);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testPatchMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         external String toString();
@@ -168,26 +174,27 @@ testPatchMember() {
       patch class Class {
         patch String toString() => 'string';
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
-  ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         expectIsPatch: true);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
+    ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+           expectIsPatch: true);
 
-  ensure(compiler, "toString", container.lookupLocalMember,
-         expectIsPatched: true, checkHasBody: true);
-  ensure(compiler, "toString", container.patch.lookupLocalMember,
-         expectIsPatch: true, checkHasBody: true);
+    ensure(compiler, "toString", container.lookupLocalMember,
+           expectIsPatched: true, checkHasBody: true);
+    ensure(compiler, "toString", container.patch.lookupLocalMember,
+           expectIsPatch: true, checkHasBody: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testPatchGetter() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         external int get field;
@@ -197,31 +204,32 @@ testPatchGetter() {
       patch class Class {
         patch int get field => 5;
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
-  ensure(compiler,
-         "field",
-         container.lookupLocalMember,
-         expectIsGetter: true,
-         expectIsPatched: true,
-         checkHasBody: true);
-  ensure(compiler,
-         "field",
-         container.patch.lookupLocalMember,
-         expectIsGetter: true,
-         expectIsPatch: true,
-         checkHasBody: true);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
+    ensure(compiler,
+           "field",
+           container.lookupLocalMember,
+           expectIsGetter: true,
+           expectIsPatched: true,
+           checkHasBody: true);
+    ensure(compiler,
+           "field",
+           container.patch.lookupLocalMember,
+           expectIsGetter: true,
+           expectIsPatch: true,
+           checkHasBody: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testRegularMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         void regular() {}
@@ -230,26 +238,27 @@ testRegularMember() {
       """
       patch class Class {
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
-  ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         expectIsPatch: true);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
+    ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+           expectIsPatch: true);
 
-  ensure(compiler, "regular", container.lookupLocalMember,
-         checkHasBody: true, expectIsRegular: true);
-  ensure(compiler, "regular", container.patch.lookupLocalMember,
-         checkHasBody: true, expectIsRegular: true);
+    ensure(compiler, "regular", container.lookupLocalMember,
+           checkHasBody: true, expectIsRegular: true);
+    ensure(compiler, "regular", container.patch.lookupLocalMember,
+           checkHasBody: true, expectIsRegular: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testGhostMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
       }
@@ -258,45 +267,47 @@ testGhostMember() {
       patch class Class {
         void ghost() {}
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
-  ensure(compiler, "Class", compiler.coreLibrary.patch.find,
-         expectIsPatch: true);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
+    ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+           expectIsPatch: true);
 
-  ensure(compiler, "ghost", container.lookupLocalMember,
-         expectIsFound: false);
-  ensure(compiler, "ghost", container.patch.lookupLocalMember,
-         checkHasBody: true, expectIsRegular: true);
+    ensure(compiler, "ghost", container.lookupLocalMember,
+           expectIsFound: false);
+    ensure(compiler, "ghost", container.patch.lookupLocalMember,
+           checkHasBody: true, expectIsRegular: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testInjectFunction() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       "",
-      "int _function() => 5;");
-  ensure(compiler,
-         "_function",
-         compiler.coreLibrary.find,
-         expectIsFound: false);
-  ensure(compiler,
-         "_function",
-         compiler.coreLibrary.patch.find,
-         checkHasBody: true, expectIsRegular: true);
+      "int _function() => 5;").then((compiler) {
+    ensure(compiler,
+           "_function",
+           compiler.coreLibrary.find,
+           expectIsFound: false);
+    ensure(compiler,
+           "_function",
+           compiler.coreLibrary.patch.find,
+           checkHasBody: true, expectIsRegular: true);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  Expect.isTrue(compiler.errors.isEmpty,
-                "Unexpected errors: ${compiler.errors}");
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    Expect.isTrue(compiler.errors.isEmpty,
+                  "Unexpected errors: ${compiler.errors}");
+  }));
 }
 
 testPatchSignatureCheck() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         external String method1();
@@ -326,72 +337,78 @@ testPatchSignatureCheck() {
         patch void method10([int str]) {}
         patch void method11({int str}) {}
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.ensureResolved(compiler);
-  container.parseNode(compiler);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.ensureResolved(compiler);
+    container.parseNode(compiler);
 
-  void expect(String methodName, List warnings, List errors) {
-    compiler.warnings.clear();
-    compiler.errors.clear();
-    compiler.resolver.resolveMethodElement(
-        ensure(compiler, methodName, container.lookupLocalMember,
-            expectIsPatched: true, checkHasBody: true));
-    Expect.equals(warnings.length, compiler.warnings.length,
-                  "Unexpected warnings: ${compiler.warnings} on $methodName");
-    for (int i = 0 ; i < warnings.length ; i++) {
-      Expect.equals(warnings[i], compiler.warnings[i].message.kind);
+    void expect(String methodName, List warnings, List errors) {
+      compiler.warnings.clear();
+      compiler.errors.clear();
+      compiler.resolver.resolveMethodElement(
+          ensure(compiler, methodName, container.lookupLocalMember,
+              expectIsPatched: true, checkHasBody: true));
+      Expect.equals(warnings.length, compiler.warnings.length,
+                    "Unexpected warnings: ${compiler.warnings} on $methodName");
+      for (int i = 0 ; i < warnings.length ; i++) {
+        Expect.equals(warnings[i], compiler.warnings[i].message.kind);
+      }
+      Expect.equals(errors.length, compiler.errors.length,
+                    "Unexpected errors: ${compiler.errors} on $methodName");
+      for (int i = 0 ; i < errors.length ; i++) {
+        Expect.equals(errors[i], compiler.errors[i].message.kind);
+      }
     }
-    Expect.equals(errors.length, compiler.errors.length,
-                  "Unexpected errors: ${compiler.errors} on $methodName");
-    for (int i = 0 ; i < errors.length ; i++) {
-      Expect.equals(errors[i], compiler.errors[i].message.kind);
-    }
-  }
 
-  expect("method1", [], [MessageKind.PATCH_RETURN_TYPE_MISMATCH]);
-  expect("method2", [], [MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH]);
-  expect("method3", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                    [MessageKind.PATCH_PARAMETER_MISMATCH]);
-  expect("method4", [], [MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH]);
-  expect("method5", [], [MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH]);
-  expect("method6", [], [MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH]);
-  expect("method7", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                    [MessageKind.PATCH_PARAMETER_MISMATCH]);
-  expect("method8", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                    [MessageKind.PATCH_PARAMETER_MISMATCH]);
-  expect("method9", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                    [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
-  expect("method10", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                     [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
-  expect("method11", [MessageKind.PATCH_POINT_TO_PARAMETER],
-                     [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
+    expect("method1", [], [MessageKind.PATCH_RETURN_TYPE_MISMATCH]);
+    expect("method2", [],
+           [MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH]);
+    expect("method3", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                      [MessageKind.PATCH_PARAMETER_MISMATCH]);
+    expect("method4", [],
+           [MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH]);
+    expect("method5", [],
+           [MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH]);
+    expect("method6", [],
+           [MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH]);
+    expect("method7", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                      [MessageKind.PATCH_PARAMETER_MISMATCH]);
+    expect("method8", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                      [MessageKind.PATCH_PARAMETER_MISMATCH]);
+    expect("method9", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                      [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
+    expect("method10", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                       [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
+    expect("method11", [MessageKind.PATCH_POINT_TO_PARAMETER],
+                       [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
+  }));
 }
 
 testExternalWithoutImplementationTopLevel() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external void foo();
       """,
       """
       // patch void foo() {}
-      """);
-  var function = ensure(compiler, "foo", compiler.coreLibrary.find);
-  compiler.resolver.resolve(function);
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testExternalWithoutImplementationTopLevel:${compiler.errors}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind ==
-          MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
-  Expect.stringEquals('Error: External method without an implementation.',
-                      compiler.errors[0].message.toString());
+      """).then((compiler) {
+    var function = ensure(compiler, "foo", compiler.coreLibrary.find);
+    compiler.resolver.resolve(function);
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testExternalWithoutImplementationTopLevel:${compiler.errors}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind ==
+            MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
+    Expect.stringEquals('Error: External method without an implementation.',
+                        compiler.errors[0].message.toString());
+  }));
 }
 
 testExternalWithoutImplementationMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         external void foo();
@@ -401,60 +418,63 @@ testExternalWithoutImplementationMember() {
       patch class Class {
         // patch void foo() {}
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
 
-  compiler.warnings.clear();
-  compiler.errors.clear();
-  compiler.resolver.resolveMethodElement(
-      ensure(compiler, "foo", container.lookupLocalMember));
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testExternalWithoutImplementationMember:${compiler.errors}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind ==
-          MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
-  Expect.stringEquals('Error: External method without an implementation.',
-                      compiler.errors[0].message.toString());
+    compiler.warnings.clear();
+    compiler.errors.clear();
+    compiler.resolver.resolveMethodElement(
+        ensure(compiler, "foo", container.lookupLocalMember));
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testExternalWithoutImplementationMember:${compiler.errors}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind ==
+            MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
+    Expect.stringEquals('Error: External method without an implementation.',
+                        compiler.errors[0].message.toString());
+  }));
 }
 
 testIsSubclass() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class A {}
       """,
       """
       patch class A {}
-      """);
-  ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
-                            expectIsPatched: true);
-  ClassElement patch = cls.patch;
-  Expect.isTrue(cls != patch);
-  Expect.isTrue(cls.isSubclassOf(patch));
-  Expect.isTrue(patch.isSubclassOf(cls));
+      """).then((compiler) {
+    ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
+                              expectIsPatched: true);
+    ClassElement patch = cls.patch;
+    Expect.isTrue(cls != patch);
+    Expect.isTrue(cls.isSubclassOf(patch));
+    Expect.isTrue(patch.isSubclassOf(cls));
+  }));
 }
 
 testPatchNonExistingTopLevel() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       // class Class {}
       """,
       """
       patch class Class {}
-      """);
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testPatchNonExistingTopLevel:${compiler.errors}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+      """).then((compiler) {
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testPatchNonExistingTopLevel:${compiler.errors}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+  }));
 }
 
 testPatchNonExistingMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {}
       """,
@@ -462,79 +482,83 @@ testPatchNonExistingMember() {
       patch class Class {
         patch void foo() {}
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testPatchNonExistingMember:${compiler.errors}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testPatchNonExistingMember:${compiler.errors}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+  }));
 }
 
 testPatchNonPatchablePatch() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
       patch var foo;
-      """);
-  ensure(compiler, "foo", compiler.coreLibrary.find);
+      """).then((compiler) {
+    ensure(compiler, "foo", compiler.coreLibrary.find);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testPatchNonPatchablePatch:${compiler.errors}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE);
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testPatchNonPatchablePatch:${compiler.errors}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE);
+  }));
 }
 
 testPatchNonPatchableOrigin() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external var foo;
       """,
       """
       patch get foo => 0;
-      """);
-  ensure(compiler, "foo", compiler.coreLibrary.find);
+      """).then((compiler) {
+    ensure(compiler, "foo", compiler.coreLibrary.find);
 
-  Expect.isTrue(compiler.warnings.isEmpty,
-                "Unexpected warnings: ${compiler.warnings}");
-  print('testPatchNonPatchableOrigin:${compiler.errors}');
-  Expect.equals(2, compiler.errors.length);
-  Expect.equals(
-      MessageKind.EXTRANEOUS_MODIFIER, compiler.errors[0].message.kind);
-  Expect.equals(
-      // TODO(ahe): Eventually, this error should be removed as it will be
-      // handled by the regular parser.
-      MessageKind.PATCH_NONPATCHABLE, compiler.errors[1].message.kind);
+    Expect.isTrue(compiler.warnings.isEmpty,
+                  "Unexpected warnings: ${compiler.warnings}");
+    print('testPatchNonPatchableOrigin:${compiler.errors}');
+    Expect.equals(2, compiler.errors.length);
+    Expect.equals(
+        MessageKind.EXTRANEOUS_MODIFIER, compiler.errors[0].message.kind);
+    Expect.equals(
+        // TODO(ahe): Eventually, this error should be removed as it will be
+        // handled by the regular parser.
+        MessageKind.PATCH_NONPATCHABLE, compiler.errors[1].message.kind);
+  }));
 }
 
 testPatchNonExternalTopLevel() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       void foo() {}
       """,
       """
       patch void foo() {}
-      """);
-  print('testPatchNonExternalTopLevel.errors:${compiler.errors}');
-  print('testPatchNonExternalTopLevel.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+      """).then((compiler) {
+    print('testPatchNonExternalTopLevel.errors:${compiler.errors}');
+    print('testPatchNonExternalTopLevel.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(compiler.warnings[0].message.kind ==
+        MessageKind.PATCH_POINT_TO_FUNCTION);
+  }));
 }
 
 testPatchNonExternalMember() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class Class {
         void foo() {}
@@ -544,131 +568,139 @@ testPatchNonExternalMember() {
       patch class Class {
         patch void foo() {}
       }
-      """);
-  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
-                         expectIsPatched: true);
-  container.parseNode(compiler);
+      """).then((compiler) {
+    var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+    container.parseNode(compiler);
 
-  print('testPatchNonExternalMember.errors:${compiler.errors}');
-  print('testPatchNonExternalMember.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+    print('testPatchNonExternalMember.errors:${compiler.errors}');
+    print('testPatchNonExternalMember.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(compiler.warnings[0].message.kind ==
+        MessageKind.PATCH_POINT_TO_FUNCTION);
+  }));
 }
 
 testPatchNonClass() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external void Class() {}
       """,
       """
       patch class Class {}
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_CLASS);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_CLASS);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_CLASS);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_CLASS);
+  }));
 }
 
 testPatchNonGetter() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external void foo() {}
       """,
       """
       patch get foo => 0;
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_GETTER);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_GETTER);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+  }));
 }
 
 testPatchNoGetter() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external set foo(var value) {}
       """,
       """
       patch get foo => 0;
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NO_GETTER);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NO_GETTER);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+  }));
 }
 
 testPatchNonSetter() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external void foo() {}
       """,
       """
       patch set foo(var value) {}
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_SETTER);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_SETTER);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+  }));
 }
 
 testPatchNoSetter() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
       patch set foo(var value) {}
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NO_SETTER);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NO_SETTER);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+  }));
 }
 
 testPatchNonFunction() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
       patch void foo() {}
-      """);
-  print('testPatchNonClass.errors:${compiler.errors}');
-  print('testPatchNonClass.warnings:${compiler.warnings}');
-  Expect.equals(1, compiler.errors.length);
-  Expect.isTrue(
-      compiler.errors[0].message.kind == MessageKind.PATCH_NON_FUNCTION);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.isTrue(
-      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+      """).then((compiler) {
+    print('testPatchNonClass.errors:${compiler.errors}');
+    print('testPatchNonClass.warnings:${compiler.warnings}');
+    Expect.equals(1, compiler.errors.length);
+    Expect.isTrue(
+        compiler.errors[0].message.kind == MessageKind.PATCH_NON_FUNCTION);
+    Expect.equals(1, compiler.warnings.length);
+    Expect.isTrue(
+        compiler.warnings[0].message.kind ==
+            MessageKind.PATCH_POINT_TO_FUNCTION);
+  }));
 }
 
 testPatchAndSelector() {
-  var compiler = applyPatch(
+  asyncTest(() => applyPatch(
       """
       class A {
         external void clear();
@@ -681,45 +713,46 @@ testPatchAndSelector() {
         int method() => 0;
         patch void clear() {}
       }
-      """);
-  ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
-                            expectIsPatched: true);
-  cls.ensureResolved(compiler);
+      """).then((compiler) {
+    ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
+                              expectIsPatched: true);
+    cls.ensureResolved(compiler);
 
-  ensure(compiler, "method", cls.patch.lookupLocalMember,
-         checkHasBody: true, expectIsRegular: true);
+    ensure(compiler, "method", cls.patch.lookupLocalMember,
+           checkHasBody: true, expectIsRegular: true);
 
-  ensure(compiler, "clear", cls.lookupLocalMember,
-         checkHasBody: true, expectIsPatched: true);
+    ensure(compiler, "clear", cls.lookupLocalMember,
+           checkHasBody: true, expectIsPatched: true);
 
-  compiler.phase = Compiler.PHASE_DONE_RESOLVING;
+    compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
-  // Check that a method just in the patch class is a target for a
-  // typed selector.
-  var selector = new Selector.call(
-      buildSourceString('method'), compiler.coreLibrary, 0);
-  var typedSelector = new TypedSelector.exact(cls.rawType, selector);
-  Element method =
-      cls.implementation.lookupLocalMember(buildSourceString('method'));
-  Expect.isTrue(selector.applies(method, compiler));
-  Expect.isTrue(typedSelector.applies(method, compiler));
+    // Check that a method just in the patch class is a target for a
+    // typed selector.
+    var selector = new Selector.call(
+        buildSourceString('method'), compiler.coreLibrary, 0);
+    var typedSelector = new TypedSelector.exact(cls.rawType, selector);
+    Element method =
+        cls.implementation.lookupLocalMember(buildSourceString('method'));
+    Expect.isTrue(selector.applies(method, compiler));
+    Expect.isTrue(typedSelector.applies(method, compiler));
 
-  // Check that the declaration method in the declaration class is a target
-  // for a typed selector.
-  selector = new Selector.call(
-      buildSourceString('clear'), compiler.coreLibrary, 0);
-  typedSelector = new TypedSelector.exact(cls.rawType, selector);
-  method = cls.lookupLocalMember(buildSourceString('clear'));
-  Expect.isTrue(selector.applies(method, compiler));
-  Expect.isTrue(typedSelector.applies(method, compiler));
+    // Check that the declaration method in the declaration class is a target
+    // for a typed selector.
+    selector = new Selector.call(
+        buildSourceString('clear'), compiler.coreLibrary, 0);
+    typedSelector = new TypedSelector.exact(cls.rawType, selector);
+    method = cls.lookupLocalMember(buildSourceString('clear'));
+    Expect.isTrue(selector.applies(method, compiler));
+    Expect.isTrue(typedSelector.applies(method, compiler));
 
-  // Check that the declaration method in the declaration class is a target
-  // for a typed selector on a subclass.
-  cls = ensure(compiler, "B", compiler.coreLibrary.find);
-  cls.ensureResolved(compiler);
-  typedSelector = new TypedSelector.exact(cls.rawType, selector);
-  Expect.isTrue(selector.applies(method, compiler));
-  Expect.isTrue(typedSelector.applies(method, compiler));
+    // Check that the declaration method in the declaration class is a target
+    // for a typed selector on a subclass.
+    cls = ensure(compiler, "B", compiler.coreLibrary.find);
+    cls.ensureResolved(compiler);
+    typedSelector = new TypedSelector.exact(cls.rawType, selector);
+    Expect.isTrue(selector.applies(method, compiler));
+    Expect.isTrue(typedSelector.applies(method, compiler));
+  }));
 }
 
 void testAnalyzeAllInjectedMembers() {
@@ -729,11 +762,13 @@ void testAnalyzeAllInjectedMembers() {
       expectedWarnings = <MessageKind>[expectedWarnings];
     }
 
-    var compiler = applyPatch('', patchText,
-                              analyzeAll: true, analyzeOnly: true);
-    compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
-    compiler.runCompiler(null);
-    compareWarningKinds(patchText, expectedWarnings, compiler.warnings);
+    asyncTest(() => applyPatch('', patchText, analyzeAll: true,
+               analyzeOnly: true).then((compiler) {
+      compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
+      return compiler.runCompiler(null).then((_) {
+        compareWarningKinds(patchText, expectedWarnings, compiler.warnings);
+      });
+    }));
   }
 
   expect('String s = 0;', MessageKind.NOT_ASSIGNABLE.warning);
@@ -761,12 +796,14 @@ void testTypecheckPatchedMembers() {
                        String s = 0;
                      }
                      """;
-  var compiler = applyPatch(originText, patchText,
-                            analyzeAll: true, analyzeOnly: true);
-  compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
-  compiler.runCompiler(null);
-  compareWarningKinds(patchText,
-      [MessageKind.NOT_ASSIGNABLE.warning], compiler.warnings);
+  asyncTest(() => applyPatch(originText, patchText,
+             analyzeAll: true, analyzeOnly: true).then((compiler) {
+    compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
+    return compiler.runCompiler(null).then((_) {
+      compareWarningKinds(patchText,
+          [MessageKind.NOT_ASSIGNABLE.warning], compiler.warnings);
+    });
+  }));
 }
 
 main() {
diff --git a/tests/compiler/dart2js/private_test.dart b/tests/compiler/dart2js/private_test.dart
index c8918a70f04..2bb9f1997b9 100644
--- a/tests/compiler/dart2js/private_test.dart
+++ b/tests/compiler/dart2js/private_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'mock_compiler.dart';
 
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
@@ -68,8 +69,9 @@ void analyze(String text, [expectedWarnings]) {
                   ''';
   Uri uri = Uri.parse('src:public');
   compiler.registerSource(uri, source);
-  compiler.runCompiler(uri);
-  compareWarningKinds(text, expectedWarnings, compiler.warnings);
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    compareWarningKinds(text, expectedWarnings, compiler.warnings);
+  }));
 }
 
 void main() {
diff --git a/tests/compiler/dart2js/reexport_handled_test.dart b/tests/compiler/dart2js/reexport_handled_test.dart
index d309fcd9474..401afb1b1e9 100644
--- a/tests/compiler/dart2js/reexport_handled_test.dart
+++ b/tests/compiler/dart2js/reexport_handled_test.dart
@@ -5,6 +5,7 @@
 library reexport_handled_test;
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'mock_compiler.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart'
     show Element,
@@ -28,19 +29,21 @@ void main() {
   compiler.registerSource(reexportingLibraryUri, REEXPORTING_LIBRARY_SOURCE);
 
   // Load exporting library before the reexporting library.
-  var exportingLibrary = compiler.libraryLoader.loadLibrary(
-      exportingLibraryUri, null, exportingLibraryUri);
-  Expect.isTrue(exportingLibrary.exportsHandled);
-  var foo = findInExports(exportingLibrary, 'foo');
-  Expect.isNotNull(foo);
-  Expect.isTrue(foo.isField());
+  asyncTest(() => compiler.libraryLoader.loadLibrary(
+      exportingLibraryUri, null, exportingLibraryUri).then((exportingLibrary) {
+    Expect.isTrue(exportingLibrary.exportsHandled);
+    var foo = findInExports(exportingLibrary, 'foo');
+    Expect.isNotNull(foo);
+    Expect.isTrue(foo.isField());
 
-  // Load reexporting library when exports are handled on the exporting library.
-  var reexportingLibrary = compiler.libraryLoader.loadLibrary(
-      reexportingLibraryUri, null, reexportingLibraryUri);
-  foo = findInExports(reexportingLibrary, 'foo');
-  Expect.isNotNull(foo);
-  Expect.isTrue(foo.isField());
+    // Load reexporting library when exports are handled on the exporting library.
+    return compiler.libraryLoader.loadLibrary(
+        reexportingLibraryUri, null, reexportingLibraryUri);
+  }).then((reexportingLibrary) {
+    var foo = findInExports(reexportingLibrary, 'foo');
+    Expect.isNotNull(foo);
+    Expect.isTrue(foo.isField());
+  }));
 }
 
 Element findInExports(LibraryElement library, String name) {
diff --git a/tests/compiler/dart2js/regress_10231_test.dart b/tests/compiler/dart2js/regress_10231_test.dart
index bc3a36f4545..2e0646139e8 100644
--- a/tests/compiler/dart2js/regress_10231_test.dart
+++ b/tests/compiler/dart2js/regress_10231_test.dart
@@ -5,13 +5,16 @@
 // Regression test for http://dartbug.com/10231.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'codegen_helper.dart';
 
 void main() {
-  var code = generate(SOURCE)['test'];
-  Expect.isNotNull(code);
-  Expect.equals(0, new RegExp('add').allMatches(code).length);
-  Expect.equals(3, new RegExp('\\+').allMatches(code).length);
+  asyncTest(() => generate(SOURCE).then((result) {
+    var code = result['test'];
+    Expect.isNotNull(code);
+    Expect.equals(0, new RegExp('add').allMatches(code).length);
+    Expect.equals(3, new RegExp('\\+').allMatches(code).length);
+  }));
 }
 
 const String SOURCE = """
diff --git a/tests/compiler/dart2js/resolution_test.dart b/tests/compiler/dart2js/resolution_test.dart
index 32f59457a5f..ac978580b01 100644
--- a/tests/compiler/dart2js/resolution_test.dart
+++ b/tests/compiler/dart2js/resolution_test.dart
@@ -6,6 +6,7 @@
 // needed by the backend.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -94,8 +95,9 @@ main() {
 void test(String code, void check(Compiler compiler)) {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(code, uri);
-  compiler.runCompiler(uri);
-  check(compiler);
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    check(compiler);
+  }));
 }
 
 void testHasRuntimeType(String code) {
diff --git a/tests/compiler/dart2js/resolver_test.dart b/tests/compiler/dart2js/resolver_test.dart
index 8587e3e03c4..0a1a9dd41bf 100644
--- a/tests/compiler/dart2js/resolver_test.dart
+++ b/tests/compiler/dart2js/resolver_test.dart
@@ -3,6 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
 import "../../../sdk/lib/_internal/compiler/implementation/resolution/resolution.dart";
@@ -841,11 +843,12 @@ List<String> asSortedStrings(Link link) {
   return result;
 }
 
-compileScript(String source) {
+Future compileScript(String source) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = compilerFor(source, uri);
-  compiler.runCompiler(uri);
-  return compiler;
+  return compiler.runCompiler(uri).then((_) {
+    return compiler;
+  });
 }
 
 checkMemberResolved(compiler, className, memberName) {
@@ -858,9 +861,9 @@ checkMemberResolved(compiler, className, memberName) {
 
 testToString() {
   final script = r"class C { toString() => 'C'; } main() { '${new C()}'; }";
-  final compiler = compileScript(script);
-
-  checkMemberResolved(compiler, 'C', buildSourceString('toString'));
+  asyncTest(() => compileScript(script).then((compiler) {
+    checkMemberResolved(compiler, 'C', buildSourceString('toString'));
+  }));
 }
 
 operatorName(op, isUnary) {
@@ -874,10 +877,10 @@ testIndexedOperator() {
         operator[]=(ix, v) {}
       }
       main() { var c = new C(); c[0]++; }""";
-  final compiler = compileScript(script);
-
-  checkMemberResolved(compiler, 'C', operatorName('[]', false));
-  checkMemberResolved(compiler, 'C', operatorName('[]=', false));
+  asyncTest(() => compileScript(script).then((compiler) {
+    checkMemberResolved(compiler, 'C', operatorName('[]', false));
+    checkMemberResolved(compiler, 'C', operatorName('[]=', false));
+  }));
 }
 
 testIncrementsAndDecrements() {
@@ -896,12 +899,12 @@ testIncrementsAndDecrements() {
         var d = new D();
         --d;
       }""";
-  final compiler = compileScript(script);
-
-  checkMemberResolved(compiler, 'A', operatorName('+', false));
-  checkMemberResolved(compiler, 'B', operatorName('+', false));
-  checkMemberResolved(compiler, 'C', operatorName('-', false));
-  checkMemberResolved(compiler, 'D', operatorName('-', false));
+  asyncTest(() => compileScript(script).then((compiler) {
+    checkMemberResolved(compiler, 'A', operatorName('+', false));
+    checkMemberResolved(compiler, 'B', operatorName('+', false));
+    checkMemberResolved(compiler, 'C', operatorName('-', false));
+    checkMemberResolved(compiler, 'D', operatorName('-', false));
+  }));
 }
 
 testOverrideHashCodeCheck() {
@@ -916,9 +919,10 @@ testOverrideHashCodeCheck() {
       main() {
         new A() == new B();
       }""";
-  final compiler = compileScript(script);
-  Expect.equals(1, compiler.warnings.length);
-  Expect.equals(MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
-                compiler.warnings[0].message.kind);
-  Expect.equals(0, compiler.errors.length);
+  asyncTest(() => compileScript(script).then((compiler) {
+    Expect.equals(1, compiler.warnings.length);
+    Expect.equals(MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
+                  compiler.warnings[0].message.kind);
+    Expect.equals(0, compiler.errors.length);
+  }));
 }
diff --git a/tests/compiler/dart2js/rewrite_better_user_test.dart b/tests/compiler/dart2js/rewrite_better_user_test.dart
index 6d1fbfe61d2..ec1fcbc1313 100644
--- a/tests/compiler/dart2js/rewrite_better_user_test.dart
+++ b/tests/compiler/dart2js/rewrite_better_user_test.dart
@@ -5,6 +5,7 @@
 // field is being gvn'ed.
 
 import 'compiler_helper.dart';
+import "package:async_helper/async_helper.dart";
 
 const String TEST = r"""
 class A {
@@ -25,11 +26,12 @@ main() {
 """;
 
 main() {
-  String generated = compileAll(TEST);
-  RegExp regexp = new RegExp('foo\\\$0\\\$bailout');
-  Iterator matches = regexp.allMatches(generated).iterator;
+  asyncTest(() => compileAll(TEST).then((generated) {
+    RegExp regexp = new RegExp('foo\\\$0\\\$bailout');
+    Iterator matches = regexp.allMatches(generated).iterator;
 
-  // We check that there is only one call to the bailout method.
-  // One match for the call, one for the definition.
-  checkNumberOfMatches(matches, 2);
+    // We check that there is only one call to the bailout method.
+    // One match for the call, one for the definition.
+    checkNumberOfMatches(matches, 2);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_and_or_test.dart b/tests/compiler/dart2js/simple_inferrer_and_or_test.dart
index 22ec51a6ea0..19926f00f95 100644
--- a/tests/compiler/dart2js/simple_inferrer_and_or_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_and_or_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST = """
@@ -57,22 +58,23 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkReturn(String name, type) {
-    var element = findElement(compiler, name);
-    Expect.equals(type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
-  }
+    checkReturn(String name, type) {
+      var element = findElement(compiler, name);
+      Expect.equals(type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
+    }
 
-  var subclassOfInterceptor =
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
+    var subclassOfInterceptor =
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
 
-  checkReturn('returnDyn1', subclassOfInterceptor);
-  checkReturn('returnDyn2', subclassOfInterceptor);
-  checkReturn('returnDyn3', subclassOfInterceptor);
-  checkReturn('returnDyn4', compiler.typesTask.dynamicType.nonNullable());
-  checkReturn('returnDyn5', compiler.typesTask.dynamicType.nonNullable());
-  checkReturn('returnDyn6', compiler.typesTask.dynamicType.nonNullable());
+    checkReturn('returnDyn1', subclassOfInterceptor);
+    checkReturn('returnDyn2', subclassOfInterceptor);
+    checkReturn('returnDyn3', subclassOfInterceptor);
+    checkReturn('returnDyn4', compiler.typesTask.dynamicType.nonNullable());
+    checkReturn('returnDyn5', compiler.typesTask.dynamicType.nonNullable());
+    checkReturn('returnDyn6', compiler.typesTask.dynamicType.nonNullable());
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_closure_test.dart b/tests/compiler/dart2js/simple_inferrer_closure_test.dart
index 6c6e1c37b5c..2ea06baa19f 100644
--- a/tests/compiler/dart2js/simple_inferrer_closure_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_closure_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST = """
@@ -97,22 +98,23 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkReturn(String name, type) {
-    var element = findElement(compiler, name);
-    Expect.equals(type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
-  }
+    checkReturn(String name, type) {
+      var element = findElement(compiler, name);
+      Expect.equals(type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
+    }
 
-  checkReturn('returnInt1', compiler.typesTask.intType);
-  checkReturn('returnInt2', compiler.typesTask.intType.nullable());
-  checkReturn('returnInt3', compiler.typesTask.intType);
-  checkReturn('returnInt4', compiler.typesTask.intType);
+    checkReturn('returnInt1', compiler.typesTask.intType);
+    checkReturn('returnInt2', compiler.typesTask.intType.nullable());
+    checkReturn('returnInt3', compiler.typesTask.intType);
+    checkReturn('returnInt4', compiler.typesTask.intType);
 
-  checkReturn('returnDyn1', compiler.typesTask.dynamicType);
-  checkReturn('returnDyn2', compiler.typesTask.dynamicType);
-  checkReturn('returnDyn3', compiler.typesTask.dynamicType);
-  checkReturn('returnNum1', compiler.typesTask.numType);
+    checkReturn('returnDyn1', compiler.typesTask.dynamicType);
+    checkReturn('returnDyn2', compiler.typesTask.dynamicType);
+    checkReturn('returnDyn3', compiler.typesTask.dynamicType);
+    checkReturn('returnNum1', compiler.typesTask.numType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart b/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
index 75bf8037391..fa7b6f5dbce 100644
--- a/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_final_field2_test.dart
@@ -6,6 +6,7 @@
 // infering types for fields.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -26,15 +27,16 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkFieldTypeInClass(String className, String fieldName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(fieldName));
-    Expect.equals(type, typesInferrer.getTypeOfElement(element));
-  }
+    checkFieldTypeInClass(String className, String fieldName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(fieldName));
+      Expect.equals(type, typesInferrer.getTypeOfElement(element));
+    }
 
-  checkFieldTypeInClass('A', 'intField', compiler.typesTask.intType);
-  checkFieldTypeInClass('A', 'stringField', compiler.typesTask.stringType);
+    checkFieldTypeInClass('A', 'intField', compiler.typesTask.intType);
+    checkFieldTypeInClass('A', 'stringField', compiler.typesTask.stringType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_final_field3_test.dart b/tests/compiler/dart2js/simple_inferrer_final_field3_test.dart
index a4a4e1f2eb6..9c76b761fcb 100644
--- a/tests/compiler/dart2js/simple_inferrer_final_field3_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_final_field3_test.dart
@@ -5,6 +5,7 @@
 // Test that we are analyzing field parameters correctly.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -25,16 +26,17 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkFieldTypeInClass(String className, String fieldName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(fieldName));
-    Expect.equals(type,
-        typesInferrer.getTypeOfElement(element).simplify(compiler));
-  }
+    checkFieldTypeInClass(String className, String fieldName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(fieldName));
+      Expect.equals(type,
+          typesInferrer.getTypeOfElement(element).simplify(compiler));
+    }
 
-  checkFieldTypeInClass('A', 'dynamicField',
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass'));
+    checkFieldTypeInClass('A', 'dynamicField',
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass'));
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_final_field_test.dart b/tests/compiler/dart2js/simple_inferrer_final_field_test.dart
index f4d5d04b2cc..6eaa89b6ec0 100644
--- a/tests/compiler/dart2js/simple_inferrer_final_field_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_final_field_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -28,20 +29,21 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkFieldTypeInClass(String className, String fieldName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(fieldName));
-    Expect.equals(type,
-        typesInferrer.getTypeOfElement(element).simplify(compiler));
-  }
+    checkFieldTypeInClass(String className, String fieldName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(fieldName));
+      Expect.equals(type,
+          typesInferrer.getTypeOfElement(element).simplify(compiler));
+    }
 
-  checkFieldTypeInClass('A', 'intField', compiler.typesTask.intType);
-  checkFieldTypeInClass('A', 'giveUpField1',
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass'));
-  checkFieldTypeInClass('A', 'giveUpField2',
-      compiler.typesTask.dynamicType.nonNullable());
-  checkFieldTypeInClass('A', 'fieldParameter', compiler.typesTask.intType);
+    checkFieldTypeInClass('A', 'intField', compiler.typesTask.intType);
+    checkFieldTypeInClass('A', 'giveUpField1',
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass'));
+    checkFieldTypeInClass('A', 'giveUpField2',
+        compiler.typesTask.dynamicType.nonNullable());
+    checkFieldTypeInClass('A', 'fieldParameter', compiler.typesTask.intType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart b/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
index 45669dd57bd..45b38787b1b 100644
--- a/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
@@ -4,6 +4,7 @@
 
 import 'package:expect/expect.dart';
 
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -95,11 +96,8 @@ main() {
 main() {
   Uri uri = new Uri(scheme: 'source');
 
-  var compiler = compilerFor(TEST1, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
-
-  checkReturn(String name, type) {
+  checkReturn(MockCompiler compiler, String name, type) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
     var element = findElement(compiler, name);
     Expect.equals(
         type,
@@ -107,27 +105,33 @@ main() {
         name);
   }
 
-  checkReturn('test1', compiler.typesTask.intType);
-  checkReturn('test2', compiler.typesTask.dynamicType.nonNullable());
-  checkReturn('test3', compiler.typesTask.intType);
-  checkReturn('test4', compiler.typesTask.mapType);
-  checkReturn('test5', compiler.typesTask.dynamicType.nonNullable());
-  checkReturn('test6', compiler.typesTask.dynamicType.nonNullable());
+  var compiler1 = compilerFor(TEST1, uri);
+  asyncTest(() => compiler1.runCompiler(uri).then((_) {
+    checkReturn(compiler1, 'test1', compiler1.typesTask.intType);
+    checkReturn(compiler1, 'test2',
+        compiler1.typesTask.dynamicType.nonNullable());
+    checkReturn(compiler1, 'test3', compiler1.typesTask.intType);
+    checkReturn(compiler1, 'test4', compiler1.typesTask.mapType);
+    checkReturn(compiler1, 'test5',
+        compiler1.typesTask.dynamicType.nonNullable());
+    checkReturn(compiler1, 'test6',
+        compiler1.typesTask.dynamicType.nonNullable());
+  }));
 
-  compiler = compilerFor(TEST2, uri);
-  compiler.runCompiler(uri);
-  typesInferrer = compiler.typesTask.typesInferrer;
+  var compiler2 = compilerFor(TEST2, uri);
+  asyncTest(() => compiler2.runCompiler(uri).then((_) {
+    checkReturn(compiler2, 'test1',
+        compiler2.typesTask.dynamicType.nonNullable());
+    checkReturn(compiler2, 'test2', compiler2.typesTask.mapType);
+    checkReturn(compiler2, 'test3', compiler2.typesTask.mapType);
+    checkReturn(compiler2, 'test4', compiler2.typesTask.mapType);
+    checkReturn(compiler2, 'test5', compiler2.typesTask.mapType);
 
-  checkReturn('test1', compiler.typesTask.dynamicType.nonNullable());
-  checkReturn('test2', compiler.typesTask.mapType);
-  checkReturn('test3', compiler.typesTask.mapType);
-  checkReturn('test4', compiler.typesTask.mapType);
-  checkReturn('test5', compiler.typesTask.mapType);
-
-  checkReturn('test6', compiler.typesTask.numType);
-  checkReturn('test7', compiler.typesTask.intType);
-  checkReturn('test8', compiler.typesTask.intType);
-  checkReturn('test9', compiler.typesTask.intType);
-  checkReturn('test10', compiler.typesTask.numType);
-  checkReturn('test11', compiler.typesTask.doubleType);
+    checkReturn(compiler2, 'test6', compiler2.typesTask.numType);
+    checkReturn(compiler2, 'test7', compiler2.typesTask.intType);
+    checkReturn(compiler2, 'test8', compiler2.typesTask.intType);
+    checkReturn(compiler2, 'test9', compiler2.typesTask.intType);
+    checkReturn(compiler2, 'test10', compiler2.typesTask.numType);
+    checkReturn(compiler2, 'test11', compiler2.typesTask.doubleType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_postfix_prefix_test.dart b/tests/compiler/dart2js/simple_inferrer_postfix_prefix_test.dart
index 6ae31748c12..427e64de0e6 100644
--- a/tests/compiler/dart2js/simple_inferrer_postfix_prefix_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_postfix_prefix_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -13,7 +14,7 @@ class A {
   set foo(value) {}
   operator[](index) => 'string';
   operator[]=(index, value) {}
-  
+
   returnDynamic1() => foo--;
   returnNum1() => --foo;
   returnNum2() => foo -= 42;
@@ -63,34 +64,35 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesTask = compiler.typesTask;
-  var typesInferrer = typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesTask = compiler.typesTask;
+    var typesInferrer = typesTask.typesInferrer;
 
-  checkReturnInClass(String className, String methodName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(methodName));
-    Expect.equals(type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
-  }
+    checkReturnInClass(String className, String methodName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(methodName));
+      Expect.equals(type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
+    }
 
-  var subclassOfInterceptor =
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
+    var subclassOfInterceptor =
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
 
-  checkReturnInClass('A', 'returnNum1', typesTask.numType);
-  checkReturnInClass('A', 'returnNum2', typesTask.numType);
-  checkReturnInClass('A', 'returnNum3', typesTask.numType);
-  checkReturnInClass('A', 'returnNum4', typesTask.numType);
-  checkReturnInClass('A', 'returnNum5', typesTask.numType);
-  checkReturnInClass('A', 'returnNum6', typesTask.numType);
-  checkReturnInClass('A', 'returnDynamic1', subclassOfInterceptor);
-  checkReturnInClass('A', 'returnDynamic2', subclassOfInterceptor);
-  checkReturnInClass('A', 'returnDynamic3', typesTask.dynamicType);
+    checkReturnInClass('A', 'returnNum1', typesTask.numType);
+    checkReturnInClass('A', 'returnNum2', typesTask.numType);
+    checkReturnInClass('A', 'returnNum3', typesTask.numType);
+    checkReturnInClass('A', 'returnNum4', typesTask.numType);
+    checkReturnInClass('A', 'returnNum5', typesTask.numType);
+    checkReturnInClass('A', 'returnNum6', typesTask.numType);
+    checkReturnInClass('A', 'returnDynamic1', subclassOfInterceptor);
+    checkReturnInClass('A', 'returnDynamic2', subclassOfInterceptor);
+    checkReturnInClass('A', 'returnDynamic3', typesTask.dynamicType);
 
-  checkReturnInClass('B', 'returnString1', typesTask.stringType);
-  checkReturnInClass('B', 'returnString2', typesTask.stringType);
-  checkReturnInClass('B', 'returnDynamic1', typesTask.dynamicType);
-  checkReturnInClass('B', 'returnDynamic2', typesTask.dynamicType);
-  checkReturnInClass('B', 'returnDynamic3', typesTask.dynamicType);
-  checkReturnInClass('B', 'returnDynamic4', typesTask.dynamicType);
+    checkReturnInClass('B', 'returnString1', typesTask.stringType);
+    checkReturnInClass('B', 'returnString2', typesTask.stringType);
+    checkReturnInClass('B', 'returnDynamic1', typesTask.dynamicType);
+    checkReturnInClass('B', 'returnDynamic2', typesTask.dynamicType);
+    checkReturnInClass('B', 'returnDynamic3', typesTask.dynamicType);
+    checkReturnInClass('B', 'returnDynamic4', typesTask.dynamicType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_relations_test.dart b/tests/compiler/dart2js/simple_inferrer_relations_test.dart
index 4b3af4a82f2..313154afa66 100644
--- a/tests/compiler/dart2js/simple_inferrer_relations_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_relations_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import
     '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show TypeMask;
@@ -51,9 +52,10 @@ main() {
 """;
 
 void main() {
-  String generated = compileAll(TEST);
-  if (generated.contains(r'=== true')) {
-    print(generated);
-    Expect.fail("missing elision of '=== true'");
-  }
+  asyncTest(() => compileAll(TEST).then((generated) {
+    if (generated.contains(r'=== true')) {
+      print(generated);
+      Expect.fail("missing elision of '=== true'");
+    }
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_test.dart b/tests/compiler/dart2js/simple_inferrer_test.dart
index 5eb96d2ce58..058741bd883 100644
--- a/tests/compiler/dart2js/simple_inferrer_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import
     '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show TypeMask;
@@ -597,123 +598,125 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesTask = compiler.typesTask;
-  var typesInferrer = typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesTask = compiler.typesTask;
+    var typesInferrer = typesTask.typesInferrer;
 
-  checkReturn(String name, type) {
-    var element = findElement(compiler, name);
-    Expect.equals(
-        type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler),
-        name);
-  }
-  var interceptorType =
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
+    checkReturn(String name, type) {
+      var element = findElement(compiler, name);
+      Expect.equals(
+          type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler),
+          name);
+    }
+    var interceptorType =
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
 
-  checkReturn('returnNum1', typesTask.numType);
-  checkReturn('returnNum2', typesTask.numType);
-  checkReturn('returnInt1', typesTask.intType);
-  checkReturn('returnInt2', typesTask.intType);
-  checkReturn('returnDouble', typesTask.doubleType);
-  checkReturn('returnGiveUp', interceptorType);
-  checkReturn('returnInt5', typesTask.intType);
-  checkReturn('returnInt6', typesTask.intType);
-  checkReturn('returnIntOrNull', typesTask.intType.nullable());
-  checkReturn('returnInt3', typesTask.intType);
-  checkReturn('returnDynamic', typesTask.dynamicType);
-  checkReturn('returnInt4', typesTask.intType);
-  checkReturn('returnInt7', typesTask.intType);
-  checkReturn('returnInt8', typesTask.intType);
-  checkReturn('returnDynamic1', typesTask.dynamicType);
-  checkReturn('returnDynamic2', typesTask.dynamicType);
-  TypeMask intType = new TypeMask.nonNullSubtype(compiler.intClass.rawType);
-  checkReturn('testIsCheck1', intType);
-  checkReturn('testIsCheck2', intType);
-  checkReturn('testIsCheck3', intType.nullable());
-  checkReturn('testIsCheck4', intType);
-  checkReturn('testIsCheck5', intType);
-  checkReturn('testIsCheck6', typesTask.dynamicType);
-  checkReturn('testIsCheck7', intType);
-  checkReturn('testIsCheck8', typesTask.dynamicType);
-  checkReturn('testIsCheck9', intType);
-  checkReturn('testIsCheck10', typesTask.dynamicType);
-  checkReturn('testIsCheck11', intType);
-  checkReturn('testIsCheck12', typesTask.dynamicType);
-  checkReturn('testIsCheck13', intType);
-  checkReturn('testIsCheck14', typesTask.dynamicType);
-  checkReturn('testIsCheck15', intType);
-  checkReturn('testIsCheck16', typesTask.dynamicType);
-  checkReturn('testIsCheck17', intType);
-  checkReturn('testIsCheck18', typesTask.dynamicType);
-  checkReturn('testIsCheck19', typesTask.dynamicType);
-  checkReturn('testIsCheck20', typesTask.dynamicType.nonNullable());
-  checkReturn('testIf1', typesTask.intType.nullable());
-  checkReturn('testIf2', typesTask.intType.nullable());
-  checkReturn('returnAsString',
-      new TypeMask.subtype(compiler.stringClass.computeType(compiler)));
-  checkReturn('returnIntAsNum', typesTask.intType);
-  checkReturn('returnAsTypedef', typesTask.functionType.nullable());
-  checkReturn('returnTopLevelGetter', typesTask.intType);
-  checkReturn('testDeadCode', typesTask.intType);
-  checkReturn('testLabeledIf', typesTask.intType.nullable());
-  checkReturn('testSwitch1', typesTask.intType
-      .union(typesTask.doubleType, compiler).nullable().simplify(compiler));
-  checkReturn('testSwitch2', typesTask.intType);
-  checkReturn('testSwitch3', interceptorType.nullable());
-  checkReturn('testSwitch4', typesTask.intType);
-  checkReturn('testSwitch5', typesTask.intType);
-  checkReturn('testContinue1', interceptorType.nullable());
-  checkReturn('testBreak1', interceptorType.nullable());
-  checkReturn('testContinue2', interceptorType.nullable());
-  checkReturn('testBreak2', typesTask.intType.nullable());
-  checkReturn('testReturnElementOfConstList1', typesTask.intType);
-  checkReturn('testReturnElementOfConstList2', typesTask.intType);
-  checkReturn('testReturnItselfOrInt', typesTask.intType);
-  checkReturn('testReturnInvokeDynamicGetter', typesTask.dynamicType);
+    checkReturn('returnNum1', typesTask.numType);
+    checkReturn('returnNum2', typesTask.numType);
+    checkReturn('returnInt1', typesTask.intType);
+    checkReturn('returnInt2', typesTask.intType);
+    checkReturn('returnDouble', typesTask.doubleType);
+    checkReturn('returnGiveUp', interceptorType);
+    checkReturn('returnInt5', typesTask.intType);
+    checkReturn('returnInt6', typesTask.intType);
+    checkReturn('returnIntOrNull', typesTask.intType.nullable());
+    checkReturn('returnInt3', typesTask.intType);
+    checkReturn('returnDynamic', typesTask.dynamicType);
+    checkReturn('returnInt4', typesTask.intType);
+    checkReturn('returnInt7', typesTask.intType);
+    checkReturn('returnInt8', typesTask.intType);
+    checkReturn('returnDynamic1', typesTask.dynamicType);
+    checkReturn('returnDynamic2', typesTask.dynamicType);
+    TypeMask intType = new TypeMask.nonNullSubtype(compiler.intClass.rawType);
+    checkReturn('testIsCheck1', intType);
+    checkReturn('testIsCheck2', intType);
+    checkReturn('testIsCheck3', intType.nullable());
+    checkReturn('testIsCheck4', intType);
+    checkReturn('testIsCheck5', intType);
+    checkReturn('testIsCheck6', typesTask.dynamicType);
+    checkReturn('testIsCheck7', intType);
+    checkReturn('testIsCheck8', typesTask.dynamicType);
+    checkReturn('testIsCheck9', intType);
+    checkReturn('testIsCheck10', typesTask.dynamicType);
+    checkReturn('testIsCheck11', intType);
+    checkReturn('testIsCheck12', typesTask.dynamicType);
+    checkReturn('testIsCheck13', intType);
+    checkReturn('testIsCheck14', typesTask.dynamicType);
+    checkReturn('testIsCheck15', intType);
+    checkReturn('testIsCheck16', typesTask.dynamicType);
+    checkReturn('testIsCheck17', intType);
+    checkReturn('testIsCheck18', typesTask.dynamicType);
+    checkReturn('testIsCheck19', typesTask.dynamicType);
+    checkReturn('testIsCheck20', typesTask.dynamicType.nonNullable());
+    checkReturn('testIf1', typesTask.intType.nullable());
+    checkReturn('testIf2', typesTask.intType.nullable());
+    checkReturn('returnAsString',
+        new TypeMask.subtype(compiler.stringClass.computeType(compiler)));
+    checkReturn('returnIntAsNum', typesTask.intType);
+    checkReturn('returnAsTypedef', typesTask.functionType.nullable());
+    checkReturn('returnTopLevelGetter', typesTask.intType);
+    checkReturn('testDeadCode', typesTask.intType);
+    checkReturn('testLabeledIf', typesTask.intType.nullable());
+    checkReturn('testSwitch1', typesTask.intType
+        .union(typesTask.doubleType, compiler)
+        .nullable().simplify(compiler));
+    checkReturn('testSwitch2', typesTask.intType);
+    checkReturn('testSwitch3', interceptorType.nullable());
+    checkReturn('testSwitch4', typesTask.intType);
+    checkReturn('testSwitch5', typesTask.intType);
+    checkReturn('testContinue1', interceptorType.nullable());
+    checkReturn('testBreak1', interceptorType.nullable());
+    checkReturn('testContinue2', interceptorType.nullable());
+    checkReturn('testBreak2', typesTask.intType.nullable());
+    checkReturn('testReturnElementOfConstList1', typesTask.intType);
+    checkReturn('testReturnElementOfConstList2', typesTask.intType);
+    checkReturn('testReturnItselfOrInt', typesTask.intType);
+    checkReturn('testReturnInvokeDynamicGetter', typesTask.dynamicType);
 
-  checkReturn('testDoWhile1', typesTask.stringType);
-  checkReturn('testDoWhile2', typesTask.nullType);
-  checkReturn('testDoWhile3', interceptorType);
-  checkReturn('testDoWhile4', typesTask.numType);
+    checkReturn('testDoWhile1', typesTask.stringType);
+    checkReturn('testDoWhile2', typesTask.nullType);
+    checkReturn('testDoWhile3', interceptorType);
+    checkReturn('testDoWhile4', typesTask.numType);
 
-  checkReturnInClass(String className, String methodName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(methodName));
-    Expect.equals(type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
-  }
+    checkReturnInClass(String className, String methodName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(methodName));
+      Expect.equals(type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
+    }
 
-  checkReturnInClass('A', 'returnInt1', typesTask.intType);
-  checkReturnInClass('A', 'returnInt2', typesTask.intType);
-  checkReturnInClass('A', 'returnInt3', typesTask.intType);
-  checkReturnInClass('A', 'returnInt4', typesTask.intType);
-  checkReturnInClass('A', 'returnInt5', typesTask.intType);
-  checkReturnInClass('A', 'returnInt6', typesTask.intType);
-  checkReturnInClass('A', '==', interceptorType);
+    checkReturnInClass('A', 'returnInt1', typesTask.intType);
+    checkReturnInClass('A', 'returnInt2', typesTask.intType);
+    checkReturnInClass('A', 'returnInt3', typesTask.intType);
+    checkReturnInClass('A', 'returnInt4', typesTask.intType);
+    checkReturnInClass('A', 'returnInt5', typesTask.intType);
+    checkReturnInClass('A', 'returnInt6', typesTask.intType);
+    checkReturnInClass('A', '==', interceptorType);
 
-  checkReturnInClass('B', 'returnInt1', typesTask.intType);
-  checkReturnInClass('B', 'returnInt2', typesTask.intType);
-  checkReturnInClass('B', 'returnInt3', typesTask.intType);
-  checkReturnInClass('B', 'returnInt4', typesTask.intType);
-  checkReturnInClass('B', 'returnInt5', typesTask.intType);
-  checkReturnInClass('B', 'returnInt6', typesTask.intType);
-  checkReturnInClass('B', 'returnInt7', typesTask.intType);
-  checkReturnInClass('B', 'returnInt8', typesTask.intType);
-  checkReturnInClass('B', 'returnInt9', typesTask.intType);
+    checkReturnInClass('B', 'returnInt1', typesTask.intType);
+    checkReturnInClass('B', 'returnInt2', typesTask.intType);
+    checkReturnInClass('B', 'returnInt3', typesTask.intType);
+    checkReturnInClass('B', 'returnInt4', typesTask.intType);
+    checkReturnInClass('B', 'returnInt5', typesTask.intType);
+    checkReturnInClass('B', 'returnInt6', typesTask.intType);
+    checkReturnInClass('B', 'returnInt7', typesTask.intType);
+    checkReturnInClass('B', 'returnInt8', typesTask.intType);
+    checkReturnInClass('B', 'returnInt9', typesTask.intType);
 
-  checkFactoryConstructor(String className, String factoryName) {
-    var cls = findElement(compiler, className);
-    var element = cls.localLookup(buildSourceString(factoryName));
-    Expect.equals(new TypeMask.nonNullExact(cls.rawType),
-                  typesInferrer.getReturnTypeOfElement(element));
-  }
-  checkFactoryConstructor('A', '');
+    checkFactoryConstructor(String className, String factoryName) {
+      var cls = findElement(compiler, className);
+      var element = cls.localLookup(buildSourceString(factoryName));
+      Expect.equals(new TypeMask.nonNullExact(cls.rawType),
+                    typesInferrer.getReturnTypeOfElement(element));
+    }
+    checkFactoryConstructor('A', '');
 
-  checkReturn('testCascade1', typesTask.growableListType);
-  checkReturn('testCascade2', new TypeMask.nonNullExact(
-      typesTask.rawTypeOf(findElement(compiler, 'CascadeHelper'))));
-  checkReturn('testSpecialization1', typesTask.numType);
-  checkReturn('testSpecialization2', typesTask.dynamicType);
-  checkReturn('testSpecialization3', typesTask.intType.nullable());
+    checkReturn('testCascade1', typesTask.growableListType);
+    checkReturn('testCascade2', new TypeMask.nonNullExact(
+        typesTask.rawTypeOf(findElement(compiler, 'CascadeHelper'))));
+    checkReturn('testSpecialization1', typesTask.numType);
+    checkReturn('testSpecialization2', typesTask.dynamicType);
+    checkReturn('testSpecialization3', typesTask.intType.nullable());
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_try_catch_test.dart b/tests/compiler/dart2js/simple_inferrer_try_catch_test.dart
index 8e47f93c060..aa29c720b87 100644
--- a/tests/compiler/dart2js/simple_inferrer_try_catch_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_try_catch_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart'
     show TypeMask;
 
@@ -166,32 +167,32 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesTask = compiler.typesTask;
-  var typesInferrer = typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesTask = compiler.typesTask;
+    var typesInferrer = typesTask.typesInferrer;
 
-  checkReturn(String name, type) {
-    var element = findElement(compiler, name);
-    Expect.equals(type,
-        typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
-  }
+    checkReturn(String name, type) {
+      var element = findElement(compiler, name);
+      Expect.equals(type,
+          typesInferrer.getReturnTypeOfElement(element).simplify(compiler));
+    }
 
-  checkReturn('returnInt1', typesTask.intType);
-  checkReturn('returnInt2', typesTask.intType);
-  checkReturn('returnInt3', typesTask.intType);
-  checkReturn('returnInt4', typesTask.intType);
-  checkReturn('returnInt5', typesTask.intType);
-  checkReturn('returnInt6',
-      new TypeMask.nonNullSubtype(compiler.intClass.rawType));
-  checkReturn('returnInt7', typesTask.intType);
+    checkReturn('returnInt1', typesTask.intType);
+    checkReturn('returnInt2', typesTask.intType);
+    checkReturn('returnInt3', typesTask.intType);
+    checkReturn('returnInt4', typesTask.intType);
+    checkReturn('returnInt5', typesTask.intType);
+    checkReturn('returnInt6',
+        new TypeMask.nonNullSubtype(compiler.intClass.rawType));
 
-  var subclassOfInterceptor =
-      findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
+    var subclassOfInterceptor =
+        findTypeMask(compiler, 'Interceptor', 'nonNullSubclass');
 
-  checkReturn('returnDyn1', subclassOfInterceptor);
-  checkReturn('returnDyn2', subclassOfInterceptor);
-  checkReturn('returnDyn3', subclassOfInterceptor);
-  checkReturn('returnDyn4', subclassOfInterceptor);
-  checkReturn('returnDyn5', subclassOfInterceptor);
-  checkReturn('returnDyn6', typesTask.dynamicType);
+    checkReturn('returnDyn1', subclassOfInterceptor);
+    checkReturn('returnDyn2', subclassOfInterceptor);
+    checkReturn('returnDyn3', subclassOfInterceptor);
+    checkReturn('returnDyn4', subclassOfInterceptor);
+    checkReturn('returnDyn5', subclassOfInterceptor);
+    checkReturn('returnDyn6', typesTask.dynamicType);
+  }));
 }
diff --git a/tests/compiler/dart2js/simple_inferrer_unregister_call_test.dart b/tests/compiler/dart2js/simple_inferrer_unregister_call_test.dart
index 81bbe0f7d23..35a2994e3f1 100644
--- a/tests/compiler/dart2js/simple_inferrer_unregister_call_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_unregister_call_test.dart
@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
-
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import 'parser_helper.dart';
 
@@ -32,14 +32,15 @@ main() {
 void main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
-  compiler.runCompiler(uri);
-  var typesInferrer = compiler.typesTask.typesInferrer;
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    var typesInferrer = compiler.typesTask.typesInferrer;
 
-  checkReturnInClass(String className, String methodName, type) {
-    var cls = findElement(compiler, className);
-    var element = cls.lookupLocalMember(buildSourceString(methodName));
-    Expect.equals(type, typesInferrer.getReturnTypeOfElement(element));
-  }
+    checkReturnInClass(String className, String methodName, type) {
+      var cls = findElement(compiler, className);
+      var element = cls.lookupLocalMember(buildSourceString(methodName));
+      Expect.equals(type, typesInferrer.getReturnTypeOfElement(element));
+    }
 
-  checkReturnInClass('A', '+', compiler.typesTask.intType);
+    checkReturnInClass('A', '+', compiler.typesTask.intType);
+  }));
 }
diff --git a/tests/compiler/dart2js/size_test.dart b/tests/compiler/dart2js/size_test.dart
index 446a6dc9aa1..96b52765501 100644
--- a/tests/compiler/dart2js/size_test.dart
+++ b/tests/compiler/dart2js/size_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import "compiler_helper.dart";
 
 const String TEST = "main() => [];";
@@ -25,10 +26,12 @@ const String DEFAULT_CORELIB_WITH_LIST = r'''
 ''';
 
 main() {
-  String generated = compileAll(TEST, coreSource: DEFAULT_CORELIB_WITH_LIST);
-  MockCompiler compiler = new MockCompiler();
-  var backend = compiler.backend;
+  asyncTest(() => compileAll(TEST, coreSource: DEFAULT_CORELIB_WITH_LIST).
+      then((generated) {
+    MockCompiler compiler = new MockCompiler();
+    var backend = compiler.backend;
 
-  // Make sure no class is emitted.
-  Expect.isFalse(generated.contains(backend.emitter.finishClassesName));
+    // Make sure no class is emitted.
+    Expect.isFalse(generated.contains(backend.emitter.finishClassesName));
+  }));
 }
diff --git a/tests/compiler/dart2js/source_mapping_test.dart b/tests/compiler/dart2js/source_mapping_test.dart
index e204f2b288f..8d404f85d13 100644
--- a/tests/compiler/dart2js/source_mapping_test.dart
+++ b/tests/compiler/dart2js/source_mapping_test.dart
@@ -2,19 +2,21 @@
 // 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.
 
+import 'dart:async';
 import "package:expect/expect.dart";
-
+import "package:async_helper/async_helper.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import "mock_compiler.dart";
 import 'parser_helper.dart';
 
-CodeBuffer compileAll(SourceFile sourceFile) {
+Future<CodeBuffer> compileAll(SourceFile sourceFile) {
   MockCompiler compiler = new MockCompiler();
   Uri uri = new Uri(path: sourceFile.filename);
   compiler.sourceFiles[uri.toString()] = sourceFile;
-  compiler.runCompiler(uri);
-  return compiler.backend.emitter.mainBuffer;
+  return compiler.runCompiler(uri).then((_) {
+    return compiler.backend.emitter.mainBuffer;
+  });
 }
 
 void testSourceMapLocations(String codeWithMarkers) {
@@ -27,27 +29,27 @@ void testSourceMapLocations(String codeWithMarkers) {
   String code = codeWithMarkers.replaceAll('@', '');
 
   SourceFile sourceFile = new SourceFile('<test script>', code);
-  CodeBuffer buffer = compileAll(sourceFile);
+  asyncTest(() => compileAll(sourceFile).then((CodeBuffer buffer) {
+    Set<int> locations = new Set<int>();
+    buffer.forEachSourceLocation((int offset, var sourcePosition) {
+      if (sourcePosition != null && sourcePosition.sourceFile == sourceFile) {
+        locations.add(sourcePosition.token.charOffset);
+      }
+    });
 
-  Set<int> locations = new Set<int>();
-  buffer.forEachSourceLocation((int offset, var sourcePosition) {
-    if (sourcePosition != null && sourcePosition.sourceFile == sourceFile) {
-      locations.add(sourcePosition.token.charOffset);
+    for (int i = 0; i < expectedLocations.length; ++i) {
+      int expectedLocation = expectedLocations[i];
+      if (!locations.contains(expectedLocation)) {
+        int originalLocation = expectedLocation + i;
+        SourceFile sourceFileWithMarkers = new SourceFile('<test script>',
+                                                          codeWithMarkers);
+        String message = sourceFileWithMarkers.getLocationMessage(
+            'Missing location', originalLocation, originalLocation + 1, true,
+            (s) => s);
+        Expect.fail(message);
+      }
     }
-  });
-
-  for (int i = 0; i < expectedLocations.length; ++i) {
-    int expectedLocation = expectedLocations[i];
-    if (!locations.contains(expectedLocation)) {
-      int originalLocation = expectedLocation + i;
-      SourceFile sourceFileWithMarkers = new SourceFile('<test script>',
-                                                        codeWithMarkers);
-      String message = sourceFileWithMarkers.getLocationMessage(
-          'Missing location', originalLocation, originalLocation + 1, true,
-          (s) => s);
-      Expect.fail(message);
-    }
-  }
+  }));
 }
 
 String FUNCTIONS_TEST = '''
diff --git a/tests/compiler/dart2js/static_closure_test.dart b/tests/compiler/dart2js/static_closure_test.dart
index 4003c61f2a7..622def209d2 100644
--- a/tests/compiler/dart2js/static_closure_test.dart
+++ b/tests/compiler/dart2js/static_closure_test.dart
@@ -5,17 +5,19 @@
 // Test that static functions are closurized as expected.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 main() {
-  String code = compileAll(r'''main() { print(main); }''');
+  asyncTest(() => compileAll(r'''main() { print(main); }''').then((code) {
+    // At some point, we will have to closurize global functions
+    // differently, at which point this test will break. Then it is time
+    // to implement a way to call a Dart closure from JS foreign
+    // functions.
 
-  // At some point, we will have to closurize global functions
-  // differently, at which point this test will break. Then it is time
-  // to implement a way to call a Dart closure from JS foreign
-  // functions.
-
-  // If this test fail, please take a look at the use of
-  // toStringWrapper in captureStackTrace in js_helper.dart.
-  Expect.isTrue(code.contains(new RegExp(r'print\([$a-z]+\.main\$closure\);')));
+    // If this test fail, please take a look at the use of
+    // toStringWrapper in captureStackTrace in js_helper.dart.
+    Expect.isTrue(code.contains(
+        new RegExp(r'print\([$a-z]+\.main\$closure\);')));
+  }));
 }
diff --git a/tests/compiler/dart2js/string_interpolation_test.dart b/tests/compiler/dart2js/string_interpolation_test.dart
index f6e3bca68df..01ea1bb96e7 100644
--- a/tests/compiler/dart2js/string_interpolation_test.dart
+++ b/tests/compiler/dart2js/string_interpolation_test.dart
@@ -3,13 +3,17 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 main() {
-  String code =
-      compileAll(r'''main() { return "${2}${true}${'a'}${3.14}"; }''');
-  Expect.isTrue(code.contains(r'2truea3.14'));
+  asyncTest(() => compileAll(
+      r'''main() { return "${2}${true}${'a'}${3.14}"; }''').then((code) {
+    Expect.isTrue(code.contains(r'2truea3.14'));
+  }));
 
-  code = compileAll(r'''main() { return "foo ${new Object()}"; }''');
-  Expect.isFalse(code.contains(r'concat'));
+  asyncTest(() => compileAll(
+      r'''main() { return "foo ${new Object()}"; }''').then((code) {
+    Expect.isFalse(code.contains(r'concat'));
+  }));
 }
diff --git a/tests/compiler/dart2js/subtype_test.dart b/tests/compiler/dart2js/subtype_test.dart
index 35a46517582..2322ee01187 100644
--- a/tests/compiler/dart2js/subtype_test.dart
+++ b/tests/compiler/dart2js/subtype_test.dart
@@ -5,6 +5,7 @@
 library subtype_test;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
@@ -23,210 +24,210 @@ void main() {
 }
 
 void testInterfaceSubtype() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       class A<T> {}
       class B<T1, T2> extends A<T1> {}
       // TODO(johnniwinther): Inheritance with different type arguments is
       // currently not supported by the implementation.
       class C<T1, T2> extends B<T2, T1> /*implements A<A<T1>>*/ {}
-      """);
+      """).then((env) {
 
-  void expect(bool value, DartType T, DartType S) {
-    Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
-  }
+    void expect(bool value, DartType T, DartType S) {
+      Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
+    }
 
-  ClassElement A = env.getElement('A');
-  ClassElement B = env.getElement('B');
-  ClassElement C = env.getElement('C');
-  DartType Object_ = env['Object'];
-  DartType num_ = env['num'];
-  DartType int_ = env['int'];
-  DartType String_ = env['String'];
-  DartType dynamic_ = env['dynamic'];
+    ClassElement A = env.getElement('A');
+    ClassElement B = env.getElement('B');
+    ClassElement C = env.getElement('C');
+    DartType Object_ = env['Object'];
+    DartType num_ = env['num'];
+    DartType int_ = env['int'];
+    DartType String_ = env['String'];
+    DartType dynamic_ = env['dynamic'];
 
-  expect(true, Object_, Object_);
-  expect(true, num_, Object_);
-  expect(true, int_, Object_);
-  expect(true, String_, Object_);
-  expect(true, dynamic_, Object_);
+    expect(true, Object_, Object_);
+    expect(true, num_, Object_);
+    expect(true, int_, Object_);
+    expect(true, String_, Object_);
+    expect(true, dynamic_, Object_);
 
-  expect(false, Object_, num_);
-  expect(true, num_, num_);
-  expect(true, int_, num_);
-  expect(false, String_, num_);
-  expect(true, dynamic_, num_);
+    expect(false, Object_, num_);
+    expect(true, num_, num_);
+    expect(true, int_, num_);
+    expect(false, String_, num_);
+    expect(true, dynamic_, num_);
 
-  expect(false, Object_, int_);
-  expect(false, num_, int_);
-  expect(true, int_, int_);
-  expect(false, String_, int_);
-  expect(true, dynamic_, int_);
+    expect(false, Object_, int_);
+    expect(false, num_, int_);
+    expect(true, int_, int_);
+    expect(false, String_, int_);
+    expect(true, dynamic_, int_);
 
-  expect(false, Object_, String_);
-  expect(false, num_, String_);
-  expect(false, int_, String_);
-  expect(true, String_, String_);
-  expect(true, dynamic_, String_);
+    expect(false, Object_, String_);
+    expect(false, num_, String_);
+    expect(false, int_, String_);
+    expect(true, String_, String_);
+    expect(true, dynamic_, String_);
 
-  expect(true, Object_, dynamic_);
-  expect(true, num_, dynamic_);
-  expect(true, int_, dynamic_);
-  expect(true, String_, dynamic_);
-  expect(true, dynamic_, dynamic_);
+    expect(true, Object_, dynamic_);
+    expect(true, num_, dynamic_);
+    expect(true, int_, dynamic_);
+    expect(true, String_, dynamic_);
+    expect(true, dynamic_, dynamic_);
 
-  DartType A_Object = instantiate(A, [Object_]);
-  DartType A_num = instantiate(A, [num_]);
-  DartType A_int = instantiate(A, [int_]);
-  DartType A_String = instantiate(A, [String_]);
-  DartType A_dynamic = instantiate(A, [dynamic_]);
+    DartType A_Object = instantiate(A, [Object_]);
+    DartType A_num = instantiate(A, [num_]);
+    DartType A_int = instantiate(A, [int_]);
+    DartType A_String = instantiate(A, [String_]);
+    DartType A_dynamic = instantiate(A, [dynamic_]);
 
-  expect(true, A_Object, Object_);
-  expect(false, A_Object, num_);
-  expect(false, A_Object, int_);
-  expect(false, A_Object, String_);
-  expect(true, A_Object, dynamic_);
+    expect(true, A_Object, Object_);
+    expect(false, A_Object, num_);
+    expect(false, A_Object, int_);
+    expect(false, A_Object, String_);
+    expect(true, A_Object, dynamic_);
 
-  expect(true, A_Object, A_Object);
-  expect(true, A_num, A_Object);
-  expect(true, A_int, A_Object);
-  expect(true, A_String, A_Object);
-  expect(true, A_dynamic, A_Object);
+    expect(true, A_Object, A_Object);
+    expect(true, A_num, A_Object);
+    expect(true, A_int, A_Object);
+    expect(true, A_String, A_Object);
+    expect(true, A_dynamic, A_Object);
 
-  expect(false, A_Object, A_num);
-  expect(true, A_num, A_num);
-  expect(true, A_int, A_num);
-  expect(false, A_String, A_num);
-  expect(true, A_dynamic, A_num);
+    expect(false, A_Object, A_num);
+    expect(true, A_num, A_num);
+    expect(true, A_int, A_num);
+    expect(false, A_String, A_num);
+    expect(true, A_dynamic, A_num);
 
-  expect(false, A_Object, A_int);
-  expect(false, A_num, A_int);
-  expect(true, A_int, A_int);
-  expect(false, A_String, A_int);
-  expect(true, A_dynamic, A_int);
+    expect(false, A_Object, A_int);
+    expect(false, A_num, A_int);
+    expect(true, A_int, A_int);
+    expect(false, A_String, A_int);
+    expect(true, A_dynamic, A_int);
 
-  expect(false, A_Object, A_String);
-  expect(false, A_num, A_String);
-  expect(false, A_int, A_String);
-  expect(true, A_String, A_String);
-  expect(true, A_dynamic, A_String);
+    expect(false, A_Object, A_String);
+    expect(false, A_num, A_String);
+    expect(false, A_int, A_String);
+    expect(true, A_String, A_String);
+    expect(true, A_dynamic, A_String);
 
-  expect(true, A_Object, A_dynamic);
-  expect(true, A_num, A_dynamic);
-  expect(true, A_int, A_dynamic);
-  expect(true, A_String, A_dynamic);
-  expect(true, A_dynamic, A_dynamic);
+    expect(true, A_Object, A_dynamic);
+    expect(true, A_num, A_dynamic);
+    expect(true, A_int, A_dynamic);
+    expect(true, A_String, A_dynamic);
+    expect(true, A_dynamic, A_dynamic);
 
-  DartType B_Object_Object = instantiate(B, [Object_, Object_]);
-  DartType B_num_num = instantiate(B, [num_, num_]);
-  DartType B_int_num = instantiate(B, [int_, num_]);
-  DartType B_dynamic_dynamic = instantiate(B, [dynamic_, dynamic_]);
-  DartType B_String_dynamic = instantiate(B, [String_, dynamic_]);
+    DartType B_Object_Object = instantiate(B, [Object_, Object_]);
+    DartType B_num_num = instantiate(B, [num_, num_]);
+    DartType B_int_num = instantiate(B, [int_, num_]);
+    DartType B_dynamic_dynamic = instantiate(B, [dynamic_, dynamic_]);
+    DartType B_String_dynamic = instantiate(B, [String_, dynamic_]);
 
-  expect(true, B_Object_Object, Object_);
-  expect(true, B_Object_Object, A_Object);
-  expect(false, B_Object_Object, A_num);
-  expect(false, B_Object_Object, A_int);
-  expect(false, B_Object_Object, A_String);
-  expect(true, B_Object_Object, A_dynamic);
+    expect(true, B_Object_Object, Object_);
+    expect(true, B_Object_Object, A_Object);
+    expect(false, B_Object_Object, A_num);
+    expect(false, B_Object_Object, A_int);
+    expect(false, B_Object_Object, A_String);
+    expect(true, B_Object_Object, A_dynamic);
 
-  expect(true, B_num_num, Object_);
-  expect(true, B_num_num, A_Object);
-  expect(true, B_num_num, A_num);
-  expect(false, B_num_num, A_int);
-  expect(false, B_num_num, A_String);
-  expect(true, B_num_num, A_dynamic);
+    expect(true, B_num_num, Object_);
+    expect(true, B_num_num, A_Object);
+    expect(true, B_num_num, A_num);
+    expect(false, B_num_num, A_int);
+    expect(false, B_num_num, A_String);
+    expect(true, B_num_num, A_dynamic);
 
-  expect(true, B_int_num, Object_);
-  expect(true, B_int_num, A_Object);
-  expect(true, B_int_num, A_num);
-  expect(true, B_int_num, A_int);
-  expect(false, B_int_num, A_String);
-  expect(true, B_int_num, A_dynamic);
+    expect(true, B_int_num, Object_);
+    expect(true, B_int_num, A_Object);
+    expect(true, B_int_num, A_num);
+    expect(true, B_int_num, A_int);
+    expect(false, B_int_num, A_String);
+    expect(true, B_int_num, A_dynamic);
 
-  expect(true, B_dynamic_dynamic, Object_);
-  expect(true, B_dynamic_dynamic, A_Object);
-  expect(true, B_dynamic_dynamic, A_num);
-  expect(true, B_dynamic_dynamic, A_int);
-  expect(true, B_dynamic_dynamic, A_String);
-  expect(true, B_dynamic_dynamic, A_dynamic);
+    expect(true, B_dynamic_dynamic, Object_);
+    expect(true, B_dynamic_dynamic, A_Object);
+    expect(true, B_dynamic_dynamic, A_num);
+    expect(true, B_dynamic_dynamic, A_int);
+    expect(true, B_dynamic_dynamic, A_String);
+    expect(true, B_dynamic_dynamic, A_dynamic);
 
-  expect(true, B_String_dynamic, Object_);
-  expect(true, B_String_dynamic, A_Object);
-  expect(false, B_String_dynamic, A_num);
-  expect(false, B_String_dynamic, A_int);
-  expect(true, B_String_dynamic, A_String);
-  expect(true, B_String_dynamic, A_dynamic);
+    expect(true, B_String_dynamic, Object_);
+    expect(true, B_String_dynamic, A_Object);
+    expect(false, B_String_dynamic, A_num);
+    expect(false, B_String_dynamic, A_int);
+    expect(true, B_String_dynamic, A_String);
+    expect(true, B_String_dynamic, A_dynamic);
 
-  expect(true, B_Object_Object, B_Object_Object);
-  expect(true, B_num_num, B_Object_Object);
-  expect(true, B_int_num, B_Object_Object);
-  expect(true, B_dynamic_dynamic, B_Object_Object);
-  expect(true, B_String_dynamic, B_Object_Object);
+    expect(true, B_Object_Object, B_Object_Object);
+    expect(true, B_num_num, B_Object_Object);
+    expect(true, B_int_num, B_Object_Object);
+    expect(true, B_dynamic_dynamic, B_Object_Object);
+    expect(true, B_String_dynamic, B_Object_Object);
 
-  expect(false, B_Object_Object, B_num_num);
-  expect(true, B_num_num, B_num_num);
-  expect(true, B_int_num, B_num_num);
-  expect(true, B_dynamic_dynamic, B_num_num);
-  expect(false, B_String_dynamic, B_num_num);
+    expect(false, B_Object_Object, B_num_num);
+    expect(true, B_num_num, B_num_num);
+    expect(true, B_int_num, B_num_num);
+    expect(true, B_dynamic_dynamic, B_num_num);
+    expect(false, B_String_dynamic, B_num_num);
 
-  expect(false, B_Object_Object, B_int_num);
-  expect(false, B_num_num, B_int_num);
-  expect(true, B_int_num, B_int_num);
-  expect(true, B_dynamic_dynamic, B_int_num);
-  expect(false, B_String_dynamic, B_int_num);
+    expect(false, B_Object_Object, B_int_num);
+    expect(false, B_num_num, B_int_num);
+    expect(true, B_int_num, B_int_num);
+    expect(true, B_dynamic_dynamic, B_int_num);
+    expect(false, B_String_dynamic, B_int_num);
 
-  expect(true, B_Object_Object, B_dynamic_dynamic);
-  expect(true, B_num_num, B_dynamic_dynamic);
-  expect(true, B_int_num, B_dynamic_dynamic);
-  expect(true, B_dynamic_dynamic, B_dynamic_dynamic);
-  expect(true, B_String_dynamic, B_dynamic_dynamic);
+    expect(true, B_Object_Object, B_dynamic_dynamic);
+    expect(true, B_num_num, B_dynamic_dynamic);
+    expect(true, B_int_num, B_dynamic_dynamic);
+    expect(true, B_dynamic_dynamic, B_dynamic_dynamic);
+    expect(true, B_String_dynamic, B_dynamic_dynamic);
 
-  expect(false, B_Object_Object, B_String_dynamic);
-  expect(false, B_num_num, B_String_dynamic);
-  expect(false, B_int_num, B_String_dynamic);
-  expect(true, B_dynamic_dynamic, B_String_dynamic);
-  expect(true, B_String_dynamic, B_String_dynamic);
+    expect(false, B_Object_Object, B_String_dynamic);
+    expect(false, B_num_num, B_String_dynamic);
+    expect(false, B_int_num, B_String_dynamic);
+    expect(true, B_dynamic_dynamic, B_String_dynamic);
+    expect(true, B_String_dynamic, B_String_dynamic);
 
-  DartType C_Object_Object = instantiate(C, [Object_, Object_]);
-  DartType C_num_num = instantiate(C, [num_, num_]);
-  DartType C_int_String = instantiate(C, [int_, String_]);
-  DartType C_dynamic_dynamic = instantiate(C, [dynamic_, dynamic_]);
+    DartType C_Object_Object = instantiate(C, [Object_, Object_]);
+    DartType C_num_num = instantiate(C, [num_, num_]);
+    DartType C_int_String = instantiate(C, [int_, String_]);
+    DartType C_dynamic_dynamic = instantiate(C, [dynamic_, dynamic_]);
 
-  expect(true, C_Object_Object, B_Object_Object);
-  expect(false, C_Object_Object, B_num_num);
-  expect(false, C_Object_Object, B_int_num);
-  expect(true, C_Object_Object, B_dynamic_dynamic);
-  expect(false, C_Object_Object, B_String_dynamic);
+    expect(true, C_Object_Object, B_Object_Object);
+    expect(false, C_Object_Object, B_num_num);
+    expect(false, C_Object_Object, B_int_num);
+    expect(true, C_Object_Object, B_dynamic_dynamic);
+    expect(false, C_Object_Object, B_String_dynamic);
 
-  expect(true, C_num_num, B_Object_Object);
-  expect(true, C_num_num, B_num_num);
-  expect(false, C_num_num, B_int_num);
-  expect(true, C_num_num, B_dynamic_dynamic);
-  expect(false, C_num_num, B_String_dynamic);
+    expect(true, C_num_num, B_Object_Object);
+    expect(true, C_num_num, B_num_num);
+    expect(false, C_num_num, B_int_num);
+    expect(true, C_num_num, B_dynamic_dynamic);
+    expect(false, C_num_num, B_String_dynamic);
 
-  expect(true, C_int_String, B_Object_Object);
-  expect(false, C_int_String, B_num_num);
-  expect(false, C_int_String, B_int_num);
-  expect(true, C_int_String, B_dynamic_dynamic);
-  expect(true, C_int_String, B_String_dynamic);
+    expect(true, C_int_String, B_Object_Object);
+    expect(false, C_int_String, B_num_num);
+    expect(false, C_int_String, B_int_num);
+    expect(true, C_int_String, B_dynamic_dynamic);
+    expect(true, C_int_String, B_String_dynamic);
 
-  expect(true, C_dynamic_dynamic, B_Object_Object);
-  expect(true, C_dynamic_dynamic, B_num_num);
-  expect(true, C_dynamic_dynamic, B_int_num);
-  expect(true, C_dynamic_dynamic, B_dynamic_dynamic);
-  expect(true, C_dynamic_dynamic, B_String_dynamic);
+    expect(true, C_dynamic_dynamic, B_Object_Object);
+    expect(true, C_dynamic_dynamic, B_num_num);
+    expect(true, C_dynamic_dynamic, B_int_num);
+    expect(true, C_dynamic_dynamic, B_dynamic_dynamic);
+    expect(true, C_dynamic_dynamic, B_String_dynamic);
 
-  expect(false, C_int_String, A_int);
-  expect(true, C_int_String, A_String);
-  // TODO(johnniwinther): Inheritance with different type arguments is
-  // currently not supported by the implementation.
-  //expect(true, C_int_String, instantiate(A, [A_int]));
-  expect(false, C_int_String, instantiate(A, [A_String]));
+    expect(false, C_int_String, A_int);
+    expect(true, C_int_String, A_String);
+    // TODO(johnniwinther): Inheritance with different type arguments is
+    // currently not supported by the implementation.
+    //expect(true, C_int_String, instantiate(A, [A_int]));
+    expect(false, C_int_String, instantiate(A, [A_String]));
+  }));
 }
 
 void testCallableSubtype() {
-
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       class U {}
       class V extends U {}
       class W extends V {}
@@ -239,31 +240,31 @@ void testCallableSubtype() {
         int m4(V v, U u);
         void m5(V v, int i);
       }
-      """);
+      """).then((env) {
+    void expect(bool value, DartType T, DartType S) {
+      Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
+    }
 
-  void expect(bool value, DartType T, DartType S) {
-    Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
-  }
+    ClassElement classA = env.getElement('A');
+    DartType A = classA.rawType;
+    DartType function = env['Function'];
+    DartType m1 = env.getMemberType(classA, 'm1');
+    DartType m2 = env.getMemberType(classA, 'm2');
+    DartType m3 = env.getMemberType(classA, 'm3');
+    DartType m4 = env.getMemberType(classA, 'm4');
+    DartType m5 = env.getMemberType(classA, 'm5');
 
-  ClassElement classA = env.getElement('A');
-  DartType A = classA.rawType;
-  DartType function = env['Function'];
-  DartType m1 = env.getMemberType(classA, 'm1');
-  DartType m2 = env.getMemberType(classA, 'm2');
-  DartType m3 = env.getMemberType(classA, 'm3');
-  DartType m4 = env.getMemberType(classA, 'm4');
-  DartType m5 = env.getMemberType(classA, 'm5');
-
-  expect(true, A, function);
-  expect(true, A, m1);
-  expect(true, A, m2);
-  expect(false, A, m3);
-  expect(false, A, m4);
-  expect(true, A, m5);
+    expect(true, A, function);
+    expect(true, A, m1);
+    expect(true, A, m2);
+    expect(false, A, m3);
+    expect(false, A, m4);
+    expect(true, A, m5);
+  }));
 }
 
 testFunctionSubtyping() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       _() => null;
       void void_() {}
       void void_2() {}
@@ -280,12 +281,11 @@ testFunctionSubtyping() {
       int int__int_int(int i1, int i2) => 0;
       void inline_void_(void f()) {}
       void inline_void__int(void f(int i)) {}
-      """);
-  functionSubtypingHelper(env);
+      """).then(functionSubtypingHelper));
 }
 
 testTypedefSubtyping() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef _();
       typedef void void_();
       typedef void void_2();
@@ -302,8 +302,7 @@ testTypedefSubtyping() {
       typedef int int__int_int(int i1, int i2);
       typedef void inline_void_(void f());
       typedef void inline_void__int(void f(int i));
-      """);
-  functionSubtypingHelper(env);
+      """).then(functionSubtypingHelper));
 }
 
 functionSubtypingHelper(TypeEnvironment env) {
@@ -363,7 +362,7 @@ functionSubtypingHelper(TypeEnvironment env) {
 }
 
 testFunctionSubtypingOptional() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       void void_() {}
       void void__int(int i) {}
       void void___int([int i]) {}
@@ -376,12 +375,11 @@ testFunctionSubtypingOptional() {
       void void___int_int([int i1, int i2]) {}
       void void___int_int_int([int i1, int i2, int i3]);
       void void___Object_int([Object o, int i]) {}
-      """);
-  functionSubtypingOptionalHelper(env);
+      """).then(functionSubtypingOptionalHelper));
 }
 
 testTypedefSubtypingOptional() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef void void_();
       typedef void void__int(int i);
       typedef void void___int([int i]);
@@ -394,8 +392,7 @@ testTypedefSubtypingOptional() {
       typedef void void___int_int([int i1, int i2]);
       typedef void void___int_int_int([int i1, int i2, int i3]);
       typedef void void___Object_int([Object o, int i]);
-      """);
-  functionSubtypingOptionalHelper(env);
+      """).then(functionSubtypingOptionalHelper));
 }
 
 functionSubtypingOptionalHelper(TypeEnvironment env) {
@@ -443,7 +440,7 @@ functionSubtypingOptionalHelper(TypeEnvironment env) {
 }
 
 testFunctionSubtypingNamed() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       void void_() {}
       void void__int(int i) {}
       void void___a_int({int a}) {}
@@ -458,12 +455,11 @@ testFunctionSubtypingNamed() {
       void void___a_int_c_int({int a, int c}) {}
       void void___b_int_c_int({int b, int c}) {}
       void void___c_int({int c}) {}
-      """);
-  functionSubtypingNamedHelper(env);
+      """).then(functionSubtypingNamedHelper));
 }
 
 testTypedefSubtypingNamed() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef void void_();
       typedef void void__int(int i);
       typedef void void___a_int({int a});
@@ -478,8 +474,7 @@ testTypedefSubtypingNamed() {
       typedef void void___a_int_c_int({int a, int c});
       typedef void void___b_int_c_int({int b, int c});
       typedef void void___c_int({int c});
-      """);
-  functionSubtypingNamedHelper(env);
+      """).then(functionSubtypingNamedHelper));
 }
 
 functionSubtypingNamedHelper(TypeEnvironment env) {
@@ -521,7 +516,7 @@ functionSubtypingNamedHelper(TypeEnvironment env) {
 }
 
 void testTypeVariableSubtype() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       class A<T> {}
       class B<T extends Object> {}
       class C<T extends num> {}
@@ -532,207 +527,207 @@ void testTypeVariableSubtype() {
       class H<T extends S, S extends T> {}
       class I<T extends S, S extends U, U extends T> {}
       class J<T extends S, S extends U, U extends S> {}
-      """);
+      """).then((env) {
+    void expect(bool value, DartType T, DartType S) {
+      Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
+    }
 
-  void expect(bool value, DartType T, DartType S) {
-    Expect.equals(value, env.isSubtype(T, S), '$T <: $S');
-  }
+    ClassElement A = env.getElement('A');
+    TypeVariableType A_T = A.thisType.typeArguments.head;
+    ClassElement B = env.getElement('B');
+    TypeVariableType B_T = B.thisType.typeArguments.head;
+    ClassElement C = env.getElement('C');
+    TypeVariableType C_T = C.thisType.typeArguments.head;
+    ClassElement D = env.getElement('D');
+    TypeVariableType D_T = D.thisType.typeArguments.head;
+    ClassElement E = env.getElement('E');
+    TypeVariableType E_T = E.thisType.typeArguments.head;
+    TypeVariableType E_S = E.thisType.typeArguments.tail.head;
+    ClassElement F = env.getElement('F');
+    TypeVariableType F_T = F.thisType.typeArguments.head;
+    TypeVariableType F_S = F.thisType.typeArguments.tail.head;
+    ClassElement G = env.getElement('G');
+    TypeVariableType G_T = G.thisType.typeArguments.head;
+    ClassElement H = env.getElement('H');
+    TypeVariableType H_T = H.thisType.typeArguments.head;
+    TypeVariableType H_S = H.thisType.typeArguments.tail.head;
+    ClassElement I = env.getElement('I');
+    TypeVariableType I_T = I.thisType.typeArguments.head;
+    TypeVariableType I_S = I.thisType.typeArguments.tail.head;
+    TypeVariableType I_U = I.thisType.typeArguments.tail.tail.head;
+    ClassElement J = env.getElement('J');
+    TypeVariableType J_T = J.thisType.typeArguments.head;
+    TypeVariableType J_S = J.thisType.typeArguments.tail.head;
+    TypeVariableType J_U = J.thisType.typeArguments.tail.tail.head;
 
-  ClassElement A = env.getElement('A');
-  TypeVariableType A_T = A.thisType.typeArguments.head;
-  ClassElement B = env.getElement('B');
-  TypeVariableType B_T = B.thisType.typeArguments.head;
-  ClassElement C = env.getElement('C');
-  TypeVariableType C_T = C.thisType.typeArguments.head;
-  ClassElement D = env.getElement('D');
-  TypeVariableType D_T = D.thisType.typeArguments.head;
-  ClassElement E = env.getElement('E');
-  TypeVariableType E_T = E.thisType.typeArguments.head;
-  TypeVariableType E_S = E.thisType.typeArguments.tail.head;
-  ClassElement F = env.getElement('F');
-  TypeVariableType F_T = F.thisType.typeArguments.head;
-  TypeVariableType F_S = F.thisType.typeArguments.tail.head;
-  ClassElement G = env.getElement('G');
-  TypeVariableType G_T = G.thisType.typeArguments.head;
-  ClassElement H = env.getElement('H');
-  TypeVariableType H_T = H.thisType.typeArguments.head;
-  TypeVariableType H_S = H.thisType.typeArguments.tail.head;
-  ClassElement I = env.getElement('I');
-  TypeVariableType I_T = I.thisType.typeArguments.head;
-  TypeVariableType I_S = I.thisType.typeArguments.tail.head;
-  TypeVariableType I_U = I.thisType.typeArguments.tail.tail.head;
-  ClassElement J = env.getElement('J');
-  TypeVariableType J_T = J.thisType.typeArguments.head;
-  TypeVariableType J_S = J.thisType.typeArguments.tail.head;
-  TypeVariableType J_U = J.thisType.typeArguments.tail.tail.head;
+    DartType Object_ = env['Object'];
+    DartType num_ = env['num'];
+    DartType int_ = env['int'];
+    DartType String_ = env['String'];
+    DartType dynamic_ = env['dynamic'];
 
-  DartType Object_ = env['Object'];
-  DartType num_ = env['num'];
-  DartType int_ = env['int'];
-  DartType String_ = env['String'];
-  DartType dynamic_ = env['dynamic'];
+    // class A<T> {}
+    expect(true, A_T, Object_);
+    expect(false, A_T, num_);
+    expect(false, A_T, int_);
+    expect(false, A_T, String_);
+    expect(true, A_T, dynamic_);
+    expect(true, A_T, A_T);
+    expect(false, A_T, B_T);
 
-  // class A<T> {}
-  expect(true, A_T, Object_);
-  expect(false, A_T, num_);
-  expect(false, A_T, int_);
-  expect(false, A_T, String_);
-  expect(true, A_T, dynamic_);
-  expect(true, A_T, A_T);
-  expect(false, A_T, B_T);
+    // class B<T extends Object> {}
+    expect(true, B_T, Object_);
+    expect(false, B_T, num_);
+    expect(false, B_T, int_);
+    expect(false, B_T, String_);
+    expect(true, B_T, dynamic_);
+    expect(true, B_T, B_T);
+    expect(false, B_T, A_T);
 
-  // class B<T extends Object> {}
-  expect(true, B_T, Object_);
-  expect(false, B_T, num_);
-  expect(false, B_T, int_);
-  expect(false, B_T, String_);
-  expect(true, B_T, dynamic_);
-  expect(true, B_T, B_T);
-  expect(false, B_T, A_T);
+    // class C<T extends num> {}
+    expect(true, C_T, Object_);
+    expect(true, C_T, num_);
+    expect(false, C_T, int_);
+    expect(false, C_T, String_);
+    expect(true, C_T, dynamic_);
+    expect(true, C_T, C_T);
+    expect(false, C_T, A_T);
 
-  // class C<T extends num> {}
-  expect(true, C_T, Object_);
-  expect(true, C_T, num_);
-  expect(false, C_T, int_);
-  expect(false, C_T, String_);
-  expect(true, C_T, dynamic_);
-  expect(true, C_T, C_T);
-  expect(false, C_T, A_T);
+    // class D<T extends int> {}
+    expect(true, D_T, Object_);
+    expect(true, D_T, num_);
+    expect(true, D_T, int_);
+    expect(false, D_T, String_);
+    expect(true, D_T, dynamic_);
+    expect(true, D_T, D_T);
+    expect(false, D_T, A_T);
 
-  // class D<T extends int> {}
-  expect(true, D_T, Object_);
-  expect(true, D_T, num_);
-  expect(true, D_T, int_);
-  expect(false, D_T, String_);
-  expect(true, D_T, dynamic_);
-  expect(true, D_T, D_T);
-  expect(false, D_T, A_T);
+    // class E<T extends S, S extends num> {}
+    expect(true, E_T, Object_);
+    expect(true, E_T, num_);
+    expect(false, E_T, int_);
+    expect(false, E_T, String_);
+    expect(true, E_T, dynamic_);
+    expect(true, E_T, E_T);
+    expect(true, E_T, E_S);
+    expect(false, E_T, A_T);
 
-  // class E<T extends S, S extends num> {}
-  expect(true, E_T, Object_);
-  expect(true, E_T, num_);
-  expect(false, E_T, int_);
-  expect(false, E_T, String_);
-  expect(true, E_T, dynamic_);
-  expect(true, E_T, E_T);
-  expect(true, E_T, E_S);
-  expect(false, E_T, A_T);
+    expect(true, E_S, Object_);
+    expect(true, E_S, num_);
+    expect(false, E_S, int_);
+    expect(false, E_S, String_);
+    expect(true, E_S, dynamic_);
+    expect(false, E_S, E_T);
+    expect(true, E_S, E_S);
+    expect(false, E_S, A_T);
 
-  expect(true, E_S, Object_);
-  expect(true, E_S, num_);
-  expect(false, E_S, int_);
-  expect(false, E_S, String_);
-  expect(true, E_S, dynamic_);
-  expect(false, E_S, E_T);
-  expect(true, E_S, E_S);
-  expect(false, E_S, A_T);
+    // class F<T extends num, S extends T> {}
+    expect(true, F_T, Object_);
+    expect(true, F_T, num_);
+    expect(false, F_T, int_);
+    expect(false, F_T, String_);
+    expect(true, F_T, dynamic_);
+    expect(false, F_T, F_S);
+    expect(true, F_T, F_T);
+    expect(false, F_T, A_T);
 
-  // class F<T extends num, S extends T> {}
-  expect(true, F_T, Object_);
-  expect(true, F_T, num_);
-  expect(false, F_T, int_);
-  expect(false, F_T, String_);
-  expect(true, F_T, dynamic_);
-  expect(false, F_T, F_S);
-  expect(true, F_T, F_T);
-  expect(false, F_T, A_T);
+    expect(true, F_S, Object_);
+    expect(true, F_S, num_);
+    expect(false, F_S, int_);
+    expect(false, F_S, String_);
+    expect(true, F_S, dynamic_);
+    expect(true, F_S, F_S);
+    expect(true, F_S, F_T);
+    expect(false, F_S, A_T);
 
-  expect(true, F_S, Object_);
-  expect(true, F_S, num_);
-  expect(false, F_S, int_);
-  expect(false, F_S, String_);
-  expect(true, F_S, dynamic_);
-  expect(true, F_S, F_S);
-  expect(true, F_S, F_T);
-  expect(false, F_S, A_T);
+    // class G<T extends T> {}
+    expect(true, G_T, Object_);
+    expect(false, G_T, num_);
+    expect(false, G_T, int_);
+    expect(false, G_T, String_);
+    expect(true, G_T, dynamic_);
+    expect(true, G_T, G_T);
+    expect(false, G_T, A_T);
 
-  // class G<T extends T> {}
-  expect(true, G_T, Object_);
-  expect(false, G_T, num_);
-  expect(false, G_T, int_);
-  expect(false, G_T, String_);
-  expect(true, G_T, dynamic_);
-  expect(true, G_T, G_T);
-  expect(false, G_T, A_T);
+    // class H<T extends S, S extends T> {}
+    expect(true, H_T, Object_);
+    expect(false, H_T, num_);
+    expect(false, H_T, int_);
+    expect(false, H_T, String_);
+    expect(true, H_T, dynamic_);
+    expect(true, H_T, H_T);
+    expect(true, H_T, H_S);
+    expect(false, H_T, A_T);
 
-  // class H<T extends S, S extends T> {}
-  expect(true, H_T, Object_);
-  expect(false, H_T, num_);
-  expect(false, H_T, int_);
-  expect(false, H_T, String_);
-  expect(true, H_T, dynamic_);
-  expect(true, H_T, H_T);
-  expect(true, H_T, H_S);
-  expect(false, H_T, A_T);
+    expect(true, H_S, Object_);
+    expect(false, H_S, num_);
+    expect(false, H_S, int_);
+    expect(false, H_S, String_);
+    expect(true, H_S, dynamic_);
+    expect(true, H_S, H_T);
+    expect(true, H_S, H_S);
+    expect(false, H_S, A_T);
 
-  expect(true, H_S, Object_);
-  expect(false, H_S, num_);
-  expect(false, H_S, int_);
-  expect(false, H_S, String_);
-  expect(true, H_S, dynamic_);
-  expect(true, H_S, H_T);
-  expect(true, H_S, H_S);
-  expect(false, H_S, A_T);
+    // class I<T extends S, S extends U, U extends T> {}
+    expect(true, I_T, Object_);
+    expect(false, I_T, num_);
+    expect(false, I_T, int_);
+    expect(false, I_T, String_);
+    expect(true, I_T, dynamic_);
+    expect(true, I_T, I_T);
+    expect(true, I_T, I_S);
+    expect(true, I_T, I_U);
+    expect(false, I_T, A_T);
 
-  // class I<T extends S, S extends U, U extends T> {}
-  expect(true, I_T, Object_);
-  expect(false, I_T, num_);
-  expect(false, I_T, int_);
-  expect(false, I_T, String_);
-  expect(true, I_T, dynamic_);
-  expect(true, I_T, I_T);
-  expect(true, I_T, I_S);
-  expect(true, I_T, I_U);
-  expect(false, I_T, A_T);
+    expect(true, I_S, Object_);
+    expect(false, I_S, num_);
+    expect(false, I_S, int_);
+    expect(false, I_S, String_);
+    expect(true, I_S, dynamic_);
+    expect(true, I_S, I_T);
+    expect(true, I_S, I_S);
+    expect(true, I_S, I_U);
+    expect(false, I_S, A_T);
 
-  expect(true, I_S, Object_);
-  expect(false, I_S, num_);
-  expect(false, I_S, int_);
-  expect(false, I_S, String_);
-  expect(true, I_S, dynamic_);
-  expect(true, I_S, I_T);
-  expect(true, I_S, I_S);
-  expect(true, I_S, I_U);
-  expect(false, I_S, A_T);
+    expect(true, I_U, Object_);
+    expect(false, I_U, num_);
+    expect(false, I_U, int_);
+    expect(false, I_U, String_);
+    expect(true, I_U, dynamic_);
+    expect(true, I_U, I_T);
+    expect(true, I_U, I_S);
+    expect(true, I_U, I_U);
+    expect(false, I_U, A_T);
 
-  expect(true, I_U, Object_);
-  expect(false, I_U, num_);
-  expect(false, I_U, int_);
-  expect(false, I_U, String_);
-  expect(true, I_U, dynamic_);
-  expect(true, I_U, I_T);
-  expect(true, I_U, I_S);
-  expect(true, I_U, I_U);
-  expect(false, I_U, A_T);
+    // class J<T extends S, S extends U, U extends S> {}
+    expect(true, J_T, Object_);
+    expect(false, J_T, num_);
+    expect(false, J_T, int_);
+    expect(false, J_T, String_);
+    expect(true, J_T, dynamic_);
+    expect(true, J_T, J_T);
+    expect(true, J_T, J_S);
+    expect(true, J_T, J_U);
+    expect(false, J_T, A_T);
 
-  // class J<T extends S, S extends U, U extends S> {}
-  expect(true, J_T, Object_);
-  expect(false, J_T, num_);
-  expect(false, J_T, int_);
-  expect(false, J_T, String_);
-  expect(true, J_T, dynamic_);
-  expect(true, J_T, J_T);
-  expect(true, J_T, J_S);
-  expect(true, J_T, J_U);
-  expect(false, J_T, A_T);
+    expect(true, J_S, Object_);
+    expect(false, J_S, num_);
+    expect(false, J_S, int_);
+    expect(false, J_S, String_);
+    expect(true, J_S, dynamic_);
+    expect(false, J_S, J_T);
+    expect(true, J_S, J_S);
+    expect(true, J_S, J_U);
+    expect(false, J_S, A_T);
 
-  expect(true, J_S, Object_);
-  expect(false, J_S, num_);
-  expect(false, J_S, int_);
-  expect(false, J_S, String_);
-  expect(true, J_S, dynamic_);
-  expect(false, J_S, J_T);
-  expect(true, J_S, J_S);
-  expect(true, J_S, J_U);
-  expect(false, J_S, A_T);
-
-  expect(true, J_U, Object_);
-  expect(false, J_U, num_);
-  expect(false, J_U, int_);
-  expect(false, J_U, String_);
-  expect(true, J_U, dynamic_);
-  expect(false, J_U, J_T);
-  expect(true, J_U, J_S);
-  expect(true, J_U, J_U);
-  expect(false, J_U, A_T);
+    expect(true, J_U, Object_);
+    expect(false, J_U, num_);
+    expect(false, J_U, int_);
+    expect(false, J_U, String_);
+    expect(true, J_U, dynamic_);
+    expect(false, J_U, J_T);
+    expect(true, J_U, J_S);
+    expect(true, J_U, J_U);
+    expect(false, J_U, A_T);
+  }));
 }
\ No newline at end of file
diff --git a/tests/compiler/dart2js/tag_mapping_test.dart b/tests/compiler/dart2js/tag_mapping_test.dart
index a669a206e72..3ae88f4f20e 100644
--- a/tests/compiler/dart2js/tag_mapping_test.dart
+++ b/tests/compiler/dart2js/tag_mapping_test.dart
@@ -5,6 +5,7 @@
 // Test of import tag to library mapping.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const MAIN_CODE = """
@@ -24,7 +25,7 @@ void main() {
     'library.dart': LIB_CODE,
   };
 
-  compileSources(sources, (MockCompiler compiler) {
+  asyncTest(() => compileSources(sources, (MockCompiler compiler) {
     LibraryElement mainApp = compiler.libraries['source:/main.dart'];
     LibraryElement lib = compiler.libraries['source:/library.dart'];
     Expect.isNotNull(mainApp, 'Could not find main.dart library');
@@ -36,5 +37,5 @@ void main() {
     // Test that we can get from the import tag in main.dart to the
     // library element representing library.dart.
     Expect.identical(lib, mainApp.getLibraryFromTag(tag));
-  });
+  }));
 }
diff --git a/tests/compiler/dart2js/tree_shaking_test.dart b/tests/compiler/dart2js/tree_shaking_test.dart
index 51580156a3a..541956f9549 100644
--- a/tests/compiler/dart2js/tree_shaking_test.dart
+++ b/tests/compiler/dart2js/tree_shaking_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST = r"""
@@ -25,8 +26,9 @@ main() {
 """;
 
 void main() {
-  String generated = compileAll(TEST);
-  Expect.isTrue(generated.contains('return 42'));
-  Expect.isTrue(generated.contains('return 54'));
-  Expect.isFalse(generated.contains('return 68'));
+  asyncTest(() => compileAll(TEST).then((generated) {
+    Expect.isTrue(generated.contains('return 42'));
+    Expect.isTrue(generated.contains('return 54'));
+    Expect.isFalse(generated.contains('return 68'));
+  }));
 }
diff --git a/tests/compiler/dart2js/type_equals_test.dart b/tests/compiler/dart2js/type_equals_test.dart
index 2493d8cbf0f..4997583cf88 100644
--- a/tests/compiler/dart2js/type_equals_test.dart
+++ b/tests/compiler/dart2js/type_equals_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "compiler_helper.dart";
 import "parser_helper.dart";
@@ -87,30 +88,30 @@ void main() {
       """,
       uri,
       analyzeAll: true, analyzeOnly: true);
-  compiler.runCompiler(uri);
+  asyncTest(() => compiler.runCompiler(uri).then((_) {
+    test(compiler, "void1", "void2", expect: true);
+    test(compiler, "int1", "int2", expect: true);
+    test(compiler, "String1", "String2", expect: true);
+    test(compiler, "ListInt1", "ListInt2", expect: true);
+    test(compiler, "ListString1", "ListString2", expect: true);
+    test(compiler, "MapIntString1", "MapIntString2", expect: true);
+    test(compiler, "TypeVar1", "TypeVar2", expect: true);
+    test(compiler, "Function1a", "Function2a", expect: true);
+    test(compiler, "Function1b", "Function2b", expect: true);
+    test(compiler, "Typedef1a", "Typedef2a", expect: true);
+    test(compiler, "Typedef1b", "Typedef2b", expect: true);
+    test(compiler, "Typedef1c", "Typedef2c", expect: true);
 
-  test(compiler, "void1", "void2", expect: true);
-  test(compiler, "int1", "int2", expect: true);
-  test(compiler, "String1", "String2", expect: true);
-  test(compiler, "ListInt1", "ListInt2", expect: true);
-  test(compiler, "ListString1", "ListString2", expect: true);
-  test(compiler, "MapIntString1", "MapIntString2", expect: true);
-  test(compiler, "TypeVar1", "TypeVar2", expect: true);
-  test(compiler, "Function1a", "Function2a", expect: true);
-  test(compiler, "Function1b", "Function2b", expect: true);
-  test(compiler, "Typedef1a", "Typedef2a", expect: true);
-  test(compiler, "Typedef1b", "Typedef2b", expect: true);
-  test(compiler, "Typedef1c", "Typedef2c", expect: true);
-
-  test(compiler, "void1", "int1", expect: false);
-  test(compiler, "int1", "String1", expect: false);
-  test(compiler, "String1", "ListInt1", expect: false);
-  test(compiler, "ListInt1", "ListString1", expect: false);
-  test(compiler, "ListString1", "MapIntString1", expect: false);
-  test(compiler, "MapIntString1", "TypeVar1", expect: false);
-  test(compiler, "TypeVar1", "Function1a", expect: false);
-  test(compiler, "Function1a", "Function1b", expect: false);
-  test(compiler, "Function1b", "Typedef1a", expect: false);
-  test(compiler, "Typedef1a", "Typedef1b", expect: false);
-  test(compiler, "Typedef1b", "Typedef1c", expect: false);
+    test(compiler, "void1", "int1", expect: false);
+    test(compiler, "int1", "String1", expect: false);
+    test(compiler, "String1", "ListInt1", expect: false);
+    test(compiler, "ListInt1", "ListString1", expect: false);
+    test(compiler, "ListString1", "MapIntString1", expect: false);
+    test(compiler, "MapIntString1", "TypeVar1", expect: false);
+    test(compiler, "TypeVar1", "Function1a", expect: false);
+    test(compiler, "Function1a", "Function1b", expect: false);
+    test(compiler, "Function1b", "Typedef1a", expect: false);
+    test(compiler, "Typedef1a", "Typedef1b", expect: false);
+    test(compiler, "Typedef1b", "Typedef1c", expect: false);
+  }));
 }
diff --git a/tests/compiler/dart2js/type_representation_test.dart b/tests/compiler/dart2js/type_representation_test.dart
index 8c651f697d7..5e6b7c5e288 100644
--- a/tests/compiler/dart2js/type_representation_test.dart
+++ b/tests/compiler/dart2js/type_representation_test.dart
@@ -5,6 +5,7 @@
 library subtype_test;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/js/js.dart';
@@ -18,7 +19,7 @@ void main() {
 }
 
 void testTypeRepresentations() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef void Typedef();
 
       void m1() {}
@@ -31,133 +32,133 @@ void testTypeRepresentations() {
       m8(int a, {String b}) {}
       m9(int a, String b, {List<int> c, d}) {}
       m10(void f(int a, [b])) {}
-      """);
+      """).then((env) {
+    TypeRepresentationGenerator typeRepresentation =
+        new TypeRepresentationGenerator(env.compiler);
 
-  TypeRepresentationGenerator typeRepresentation =
-      new TypeRepresentationGenerator(env.compiler);
+    Expression onVariable(TypeVariableType variable) {
+      return new VariableUse(variable.name.slowToString());
+    }
 
-  Expression onVariable(TypeVariableType variable) {
-    return new VariableUse(variable.name.slowToString());
-  }
+    String stringify(Expression expression) {
+      return prettyPrint(expression, env.compiler).buffer.toString();
+    }
 
-  String stringify(Expression expression) {
-    return prettyPrint(expression, env.compiler).buffer.toString();
-  }
+    void expect(String expectedRepresentation, DartType type) {
+      Expression expression =
+          typeRepresentation.getTypeRepresentation(type, onVariable);
+      Expect.stringEquals(expectedRepresentation, stringify(expression));
+    }
 
-  void expect(String expectedRepresentation, DartType type) {
-    Expression expression =
-        typeRepresentation.getTypeRepresentation(type, onVariable);
-    Expect.stringEquals(expectedRepresentation, stringify(expression));
-  }
+    String getJsName(ClassElement cls) {
+      Expression name = typeRepresentation.getJavaScriptClassName(cls);
+      return stringify(name);
+    }
 
-  String getJsName(ClassElement cls) {
-    Expression name = typeRepresentation.getJavaScriptClassName(cls);
-    return stringify(name);
-  }
+    JavaScriptBackend backend = env.compiler.backend;
+    String func = backend.namer.functionTypeTag();
+    String retvoid = backend.namer.functionTypeVoidReturnTag();
+    String ret = backend.namer.functionTypeReturnTypeTag();
+    String args = backend.namer.functionTypeRequiredParametersTag();
+    String opt = backend.namer.functionTypeOptionalParametersTag();
+    String named = backend.namer.functionTypeNamedParametersTag();
 
-  JavaScriptBackend backend = env.compiler.backend;
-  String func = backend.namer.functionTypeTag();
-  String retvoid = backend.namer.functionTypeVoidReturnTag();
-  String ret = backend.namer.functionTypeReturnTypeTag();
-  String args = backend.namer.functionTypeRequiredParametersTag();
-  String opt = backend.namer.functionTypeOptionalParametersTag();
-  String named = backend.namer.functionTypeNamedParametersTag();
+    ClassElement List_ = env.getElement('List');
+    TypeVariableType List_E = List_.typeVariables.head;
+    ClassElement Map_ = env.getElement('Map');
+    TypeVariableType Map_K = Map_.typeVariables.head;
+    TypeVariableType Map_V = Map_.typeVariables.tail.head;
 
-  ClassElement List_ = env.getElement('List');
-  TypeVariableType List_E = List_.typeVariables.head;
-  ClassElement Map_ = env.getElement('Map');
-  TypeVariableType Map_K = Map_.typeVariables.head;
-  TypeVariableType Map_V = Map_.typeVariables.tail.head;
+    DartType Object_ = env['Object'];
+    DartType int_ = env['int'];
+    DartType String_ = env['String'];
+    DartType dynamic_ = env['dynamic'];
+    DartType Typedef_ = env['Typedef'];
 
-  DartType Object_ = env['Object'];
-  DartType int_ = env['int'];
-  DartType String_ = env['String'];
-  DartType dynamic_ = env['dynamic'];
-  DartType Typedef_ = env['Typedef'];
+    String List_rep = getJsName(List_);
+    String List_E_rep = stringify(onVariable(List_E));
+    String Map_rep = getJsName(Map_);
+    String Map_K_rep = stringify(onVariable(Map_K));
+    String Map_V_rep = stringify(onVariable(Map_V));
 
-  String List_rep = getJsName(List_);
-  String List_E_rep = stringify(onVariable(List_E));
-  String Map_rep = getJsName(Map_);
-  String Map_K_rep = stringify(onVariable(Map_K));
-  String Map_V_rep = stringify(onVariable(Map_V));
+    String Object_rep = getJsName(Object_.element);
+    String int_rep = getJsName(int_.element);
+    String String_rep = getJsName(String_.element);
 
-  String Object_rep = getJsName(Object_.element);
-  String int_rep = getJsName(int_.element);
-  String String_rep = getJsName(String_.element);
+    expect('$int_rep', int_);
+    expect('$String_rep', String_);
+    expect('null', dynamic_);
 
-  expect('$int_rep', int_);
-  expect('$String_rep', String_);
-  expect('null', dynamic_);
+    // List<E>
+    expect('[$List_rep, $List_E_rep]', List_.computeType(env.compiler));
+    // List
+    expect('$List_rep', List_.rawType);
+    // List<dynamic>
+    expect('[$List_rep, null]', instantiate(List_, [dynamic_]));
+    // List<int>
+    expect('[$List_rep, $int_rep]', instantiate(List_, [int_]));
+    // List<Typedef>
+    expect('[$List_rep, {$func: "void_", $retvoid: true}]',
+        instantiate(List_, [Typedef_]));
 
-  // List<E>
-  expect('[$List_rep, $List_E_rep]', List_.computeType(env.compiler));
-  // List
-  expect('$List_rep', List_.rawType);
-  // List<dynamic>
-  expect('[$List_rep, null]', instantiate(List_, [dynamic_]));
-  // List<int>
-  expect('[$List_rep, $int_rep]', instantiate(List_, [int_]));
-  // List<Typedef>
-  expect('[$List_rep, {$func: "void_", $retvoid: true}]',
-      instantiate(List_, [Typedef_]));
+    // Map<K,V>
+    expect('[$Map_rep, $Map_K_rep, $Map_V_rep]', Map_.computeType(env.compiler));
+    // Map
+    expect('$Map_rep', Map_.rawType);
+    // Map<dynamic,dynamic>
+    expect('[$Map_rep, null, null]', instantiate(Map_, [dynamic_, dynamic_]));
+    // Map<int,String>
+    expect('[$Map_rep, $int_rep, $String_rep]',
+        instantiate(Map_, [int_, String_]));
 
-  // Map<K,V>
-  expect('[$Map_rep, $Map_K_rep, $Map_V_rep]', Map_.computeType(env.compiler));
-  // Map
-  expect('$Map_rep', Map_.rawType);
-  // Map<dynamic,dynamic>
-  expect('[$Map_rep, null, null]', instantiate(Map_, [dynamic_, dynamic_]));
-  // Map<int,String>
-  expect('[$Map_rep, $int_rep, $String_rep]',
-      instantiate(Map_, [int_, String_]));
+    // void m1() {}
+    expect('{$func: "void_", $retvoid: true}',
+        env.getElement('m1').computeType(env.compiler));
 
-  // void m1() {}
-  expect('{$func: "void_", $retvoid: true}',
-      env.getElement('m1').computeType(env.compiler));
+    // int m2() => 0;
+    expect('{$func: "int_", $ret: $int_rep}',
+        env.getElement('m2').computeType(env.compiler));
 
-  // int m2() => 0;
-  expect('{$func: "int_", $ret: $int_rep}',
-      env.getElement('m2').computeType(env.compiler));
+    // List<int> m3() => null;
+    expect('{$func: "List_", $ret: [$List_rep, $int_rep]}',
+        env.getElement('m3').computeType(env.compiler));
 
-  // List<int> m3() => null;
-  expect('{$func: "List_", $ret: [$List_rep, $int_rep]}',
-      env.getElement('m3').computeType(env.compiler));
+    // m4() {}
+    expect('{$func: "args0"}',
+        env.getElement('m4').computeType(env.compiler));
 
-  // m4() {}
-  expect('{$func: "args0"}',
-      env.getElement('m4').computeType(env.compiler));
+    // m5(int a, String b) {}
+    expect('{$func: "dynamic__int_String", $args: [$int_rep, $String_rep]}',
+        env.getElement('m5').computeType(env.compiler));
 
-  // m5(int a, String b) {}
-  expect('{$func: "dynamic__int_String", $args: [$int_rep, $String_rep]}',
-      env.getElement('m5').computeType(env.compiler));
+    // m6(int a, [String b]) {}
+    expect('{$func: "dynamic__int__String", $args: [$int_rep],'
+           ' $opt: [$String_rep]}',
+        env.getElement('m6').computeType(env.compiler));
 
-  // m6(int a, [String b]) {}
-  expect('{$func: "dynamic__int__String", $args: [$int_rep],'
-         ' $opt: [$String_rep]}',
-      env.getElement('m6').computeType(env.compiler));
+    // m7(int a, String b, [List<int> c, d]) {}
+    expect('{$func: "dynamic__int_String__List_dynamic",'
+           ' $args: [$int_rep, $String_rep],'
+           ' $opt: [[$List_rep, $int_rep], null]}',
+        env.getElement('m7').computeType(env.compiler));
 
-  // m7(int a, String b, [List<int> c, d]) {}
-  expect('{$func: "dynamic__int_String__List_dynamic",'
-         ' $args: [$int_rep, $String_rep],'
-         ' $opt: [[$List_rep, $int_rep], null]}',
-      env.getElement('m7').computeType(env.compiler));
+    // m8(int a, {String b}) {}
+    expect('{$func: "dynamic__int__String0",'
+           ' $args: [$int_rep], $named: {b: $String_rep}}',
+        env.getElement('m8').computeType(env.compiler));
 
-  // m8(int a, {String b}) {}
-  expect('{$func: "dynamic__int__String0",'
-         ' $args: [$int_rep], $named: {b: $String_rep}}',
-      env.getElement('m8').computeType(env.compiler));
+    // m9(int a, String b, {List<int> c, d}) {}
+    expect('{$func: "dynamic__int_String__List_dynamic0",'
+           ' $args: [$int_rep, $String_rep],'
+           ' $named: {c: [$List_rep, $int_rep], d: null}}',
+        env.getElement('m9').computeType(env.compiler));
 
-  // m9(int a, String b, {List<int> c, d}) {}
-  expect('{$func: "dynamic__int_String__List_dynamic0",'
-         ' $args: [$int_rep, $String_rep],'
-         ' $named: {c: [$List_rep, $int_rep], d: null}}',
-      env.getElement('m9').computeType(env.compiler));
-
-  // m10(void f(int a, [b])) {}
-  expect('{$func: "dynamic__void__int__dynamic", $args:'
-         ' [{$func: "void__int__dynamic",'
-         ' $retvoid: true, $args: [$int_rep], $opt: [null]}]}',
-      env.getElement('m10').computeType(env.compiler));
+    // m10(void f(int a, [b])) {}
+    expect('{$func: "dynamic__void__int__dynamic", $args:'
+           ' [{$func: "void__int__dynamic",'
+           ' $retvoid: true, $args: [$int_rep], $opt: [null]}]}',
+        env.getElement('m10').computeType(env.compiler));
+  }));
 }
 
 
diff --git a/tests/compiler/dart2js/type_substitution_test.dart b/tests/compiler/dart2js/type_substitution_test.dart
index 7f2d9df6a12..483e506ebad 100644
--- a/tests/compiler/dart2js/type_substitution_test.dart
+++ b/tests/compiler/dart2js/type_substitution_test.dart
@@ -5,6 +5,7 @@
 library type_substitution_test;
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "compiler_helper.dart";
 import "parser_helper.dart";
@@ -48,43 +49,46 @@ void main() {
 }
 
 void testAsInstanceOf() {
-  var env = new TypeEnvironment('''
+  asyncTest(() => TypeEnvironment.create('''
       class A<T> {}
       class B<T> {}
       class C<T> extends A<T> {}
       class D<T> extends A<int> {}
       class E<T> extends A<A<T>> {}
-      class F<T, U> extends B<F<T, String>> implements A<F<B<U>, int>> {}''');
-  var compiler = env.compiler;
+      class F<T, U> extends B<F<T, String>> implements A<F<B<U>, int>> {}
+      ''').then((env) {
+    var compiler = env.compiler;
 
-  ClassElement A = env.getElement("A");
-  ClassElement B = env.getElement("B");
-  ClassElement C = env.getElement("C");
-  ClassElement D = env.getElement("D");
-  ClassElement E = env.getElement("E");
-  ClassElement F = env.getElement("F");
+    ClassElement A = env.getElement("A");
+    ClassElement B = env.getElement("B");
+    ClassElement C = env.getElement("C");
+    ClassElement D = env.getElement("D");
+    ClassElement E = env.getElement("E");
+    ClassElement F = env.getElement("F");
 
-  DartType numType = env['num'];
-  DartType intType = env['int'];
-  DartType stringType = env['String'];
+    DartType numType = env['num'];
+    DartType intType = env['int'];
+    DartType stringType = env['String'];
 
-  InterfaceType C_int = instantiate(C, [intType]);
-  Expect.equals(instantiate(C, [intType]), C_int);
-  Expect.equals(instantiate(A, [intType]), C_int.asInstanceOf(A));
+    InterfaceType C_int = instantiate(C, [intType]);
+    Expect.equals(instantiate(C, [intType]), C_int);
+    Expect.equals(instantiate(A, [intType]), C_int.asInstanceOf(A));
 
-  InterfaceType D_int = instantiate(D, [stringType]);
-  Expect.equals(instantiate(A, [intType]), D_int.asInstanceOf(A));
+    InterfaceType D_int = instantiate(D, [stringType]);
+    Expect.equals(instantiate(A, [intType]), D_int.asInstanceOf(A));
 
-  InterfaceType E_int = instantiate(E, [intType]);
-  Expect.equals(instantiate(A, [instantiate(A, [intType])]),
-                E_int.asInstanceOf(A));
+    InterfaceType E_int = instantiate(E, [intType]);
+    Expect.equals(instantiate(A, [instantiate(A, [intType])]),
+                  E_int.asInstanceOf(A));
 
-  InterfaceType F_int_string = instantiate(F, [intType, stringType]);
-  Expect.equals(instantiate(B, [instantiate(F, [intType, stringType])]),
-                F_int_string.asInstanceOf(B));
-  Expect.equals(instantiate(A, [instantiate(F, [instantiate(B, [stringType]),
-						intType])]),
-                F_int_string.asInstanceOf(A));
+    InterfaceType F_int_string = instantiate(F, [intType, stringType]);
+    Expect.equals(instantiate(B, [instantiate(F, [intType, stringType])]),
+                  F_int_string.asInstanceOf(B));
+    Expect.equals(instantiate(A, [instantiate(F, [instantiate(B, [stringType]),
+                  intType])]),
+                  F_int_string.asInstanceOf(A));
+
+  }));
 }
 
 /**
@@ -101,7 +105,7 @@ bool testSubstitution(compiler, arguments, parameters,
 }
 
 void testTypeSubstitution() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef void Typedef1<X,Y>(X x1, Y y2);
       typedef void Typedef2<Z>(Z z1);
 
@@ -153,78 +157,79 @@ void testTypeSubstitution() {
         void Typedef1e(Typedef2<S> a) {}
         void Typedef2e(Typedef2<String> b) {}
       }
-      """);
-  var compiler = env.compiler;
+      """).then((env) {
+    var compiler = env.compiler;
 
-  InterfaceType Class_T_S = env["Class"];
-  Expect.isNotNull(Class_T_S);
-  Expect.identical(Class_T_S.kind, TypeKind.INTERFACE);
-  Expect.equals(2, length(Class_T_S.typeArguments));
+    InterfaceType Class_T_S = env["Class"];
+    Expect.isNotNull(Class_T_S);
+    Expect.identical(Class_T_S.kind, TypeKind.INTERFACE);
+    Expect.equals(2, length(Class_T_S.typeArguments));
 
-  DartType T = Class_T_S.typeArguments.head;
-  Expect.isNotNull(T);
-  Expect.identical(T.kind, TypeKind.TYPE_VARIABLE);
+    DartType T = Class_T_S.typeArguments.head;
+    Expect.isNotNull(T);
+    Expect.identical(T.kind, TypeKind.TYPE_VARIABLE);
 
-  DartType S = Class_T_S.typeArguments.tail.head;
-  Expect.isNotNull(S);
-  Expect.identical(S.kind, TypeKind.TYPE_VARIABLE);
+    DartType S = Class_T_S.typeArguments.tail.head;
+    Expect.isNotNull(S);
+    Expect.identical(S.kind, TypeKind.TYPE_VARIABLE);
 
-  DartType intType = env['int'];//getType(compiler, "int1");
-  Expect.isNotNull(intType);
-  Expect.identical(intType.kind, TypeKind.INTERFACE);
+    DartType intType = env['int'];//getType(compiler, "int1");
+    Expect.isNotNull(intType);
+    Expect.identical(intType.kind, TypeKind.INTERFACE);
 
-  DartType StringType = env['String'];//getType(compiler, "String1");
-  Expect.isNotNull(StringType);
-  Expect.identical(StringType.kind, TypeKind.INTERFACE);
+    DartType StringType = env['String'];//getType(compiler, "String1");
+    Expect.isNotNull(StringType);
+    Expect.identical(StringType.kind, TypeKind.INTERFACE);
 
-  var parameters = new Link<DartType>.fromList(<DartType>[T, S]);
-  var arguments = new Link<DartType>.fromList(<DartType>[intType, StringType]);
+    var parameters = new Link<DartType>.fromList(<DartType>[T, S]);
+    var arguments = new Link<DartType>.fromList(<DartType>[intType, StringType]);
 
-  // TODO(johnniwinther): Create types directly from strings to improve test
-  // readability.
+    // TODO(johnniwinther): Create types directly from strings to improve test
+    // readability.
 
-  testSubstitution(compiler, arguments, parameters, "void1", "void2");
-  testSubstitution(compiler, arguments, parameters, "dynamic1", "dynamic2");
-  testSubstitution(compiler, arguments, parameters, "int1", "int2");
-  testSubstitution(compiler, arguments, parameters, "String1", "String2");
-  testSubstitution(compiler, arguments, parameters, "ListInt1", "ListInt2");
-  testSubstitution(compiler, arguments, parameters, "ListT1", "ListT2");
-  testSubstitution(compiler, arguments, parameters, "ListS1", "ListS2");
-  testSubstitution(compiler, arguments, parameters, "ListListT1", "ListListT2");
-  testSubstitution(compiler, arguments, parameters, "ListRaw1", "ListRaw2");
-  testSubstitution(compiler, arguments, parameters,
-                    "ListDynamic1", "ListDynamic2");
-  testSubstitution(compiler, arguments, parameters,
-                   "MapIntString1", "MapIntString2");
-  testSubstitution(compiler, arguments, parameters,
-                   "MapTString1", "MapTString2");
-  testSubstitution(compiler, arguments, parameters,
-                   "MapDynamicString1", "MapDynamicString2");
-  testSubstitution(compiler, arguments, parameters, "TypeVarT1", "TypeVarT2");
-  testSubstitution(compiler, arguments, parameters, "TypeVarS1", "TypeVarS2");
-  testSubstitution(compiler, arguments, parameters, "Function1a", "Function2a");
-  testSubstitution(compiler, arguments, parameters, "Function1b", "Function2b");
-  testSubstitution(compiler, arguments, parameters, "Function1c", "Function2c");
-  testSubstitution(compiler, arguments, parameters, "Typedef1a", "Typedef2a");
-  testSubstitution(compiler, arguments, parameters, "Typedef1b", "Typedef2b");
-  testSubstitution(compiler, arguments, parameters, "Typedef1c", "Typedef2c");
-  testSubstitution(compiler, arguments, parameters, "Typedef1d", "Typedef2d");
-  testSubstitution(compiler, arguments, parameters, "Typedef1e", "Typedef2e");
+    testSubstitution(compiler, arguments, parameters, "void1", "void2");
+    testSubstitution(compiler, arguments, parameters, "dynamic1", "dynamic2");
+    testSubstitution(compiler, arguments, parameters, "int1", "int2");
+    testSubstitution(compiler, arguments, parameters, "String1", "String2");
+    testSubstitution(compiler, arguments, parameters, "ListInt1", "ListInt2");
+    testSubstitution(compiler, arguments, parameters, "ListT1", "ListT2");
+    testSubstitution(compiler, arguments, parameters, "ListS1", "ListS2");
+    testSubstitution(compiler, arguments, parameters, "ListListT1", "ListListT2");
+    testSubstitution(compiler, arguments, parameters, "ListRaw1", "ListRaw2");
+    testSubstitution(compiler, arguments, parameters,
+                      "ListDynamic1", "ListDynamic2");
+    testSubstitution(compiler, arguments, parameters,
+                     "MapIntString1", "MapIntString2");
+    testSubstitution(compiler, arguments, parameters,
+                     "MapTString1", "MapTString2");
+    testSubstitution(compiler, arguments, parameters,
+                     "MapDynamicString1", "MapDynamicString2");
+    testSubstitution(compiler, arguments, parameters, "TypeVarT1", "TypeVarT2");
+    testSubstitution(compiler, arguments, parameters, "TypeVarS1", "TypeVarS2");
+    testSubstitution(compiler, arguments, parameters, "Function1a", "Function2a");
+    testSubstitution(compiler, arguments, parameters, "Function1b", "Function2b");
+    testSubstitution(compiler, arguments, parameters, "Function1c", "Function2c");
+    testSubstitution(compiler, arguments, parameters, "Typedef1a", "Typedef2a");
+    testSubstitution(compiler, arguments, parameters, "Typedef1b", "Typedef2b");
+    testSubstitution(compiler, arguments, parameters, "Typedef1c", "Typedef2c");
+    testSubstitution(compiler, arguments, parameters, "Typedef1d", "Typedef2d");
+    testSubstitution(compiler, arguments, parameters, "Typedef1e", "Typedef2e");
 
-  // Substitution in unalias.
-  DartType Typedef2_int_String = getType(compiler, "Typedef2a");
-  Expect.isNotNull(Typedef2_int_String);
-  DartType Function_int_String = getType(compiler, "Function2b");
-  Expect.isNotNull(Function_int_String);
-  DartType unalias1 = Typedef2_int_String.unalias(compiler);
-  Expect.equals(Function_int_String, unalias1,
-      '$Typedef2_int_String.unalias=$unalias1 != $Function_int_String');
+    // Substitution in unalias.
+    DartType Typedef2_int_String = getType(compiler, "Typedef2a");
+    Expect.isNotNull(Typedef2_int_String);
+    DartType Function_int_String = getType(compiler, "Function2b");
+    Expect.isNotNull(Function_int_String);
+    DartType unalias1 = Typedef2_int_String.unalias(compiler);
+    Expect.equals(Function_int_String, unalias1,
+        '$Typedef2_int_String.unalias=$unalias1 != $Function_int_String');
 
-  DartType Typedef1 = getType(compiler, "Typedef1c");
-  Expect.isNotNull(Typedef1);
-  DartType Function_dynamic_dynamic = getType(compiler, "Function1c");
-  Expect.isNotNull(Function_dynamic_dynamic);
-  DartType unalias2 = Typedef1.unalias(compiler);
-  Expect.equals(Function_dynamic_dynamic, unalias2,
-      '$Typedef1.unalias=$unalias2 != $Function_dynamic_dynamic');
+    DartType Typedef1 = getType(compiler, "Typedef1c");
+    Expect.isNotNull(Typedef1);
+    DartType Function_dynamic_dynamic = getType(compiler, "Function1c");
+    Expect.isNotNull(Function_dynamic_dynamic);
+    DartType unalias2 = Typedef1.unalias(compiler);
+    Expect.equals(Function_dynamic_dynamic, unalias2,
+        '$Typedef1.unalias=$unalias2 != $Function_dynamic_dynamic');
+  }));
 }
diff --git a/tests/compiler/dart2js/type_test_helper.dart b/tests/compiler/dart2js/type_test_helper.dart
index db1a43f8a95..5a21201d9da 100644
--- a/tests/compiler/dart2js/type_test_helper.dart
+++ b/tests/compiler/dart2js/type_test_helper.dart
@@ -4,6 +4,7 @@
 
 library type_test_helper;
 
+import 'dart:async';
 import "package:expect/expect.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "parser_helper.dart" show SourceString;
@@ -22,7 +23,7 @@ GenericType instantiate(TypeDeclarationElement element,
 class TypeEnvironment {
   final MockCompiler compiler;
 
-  factory TypeEnvironment(String source) {
+  static Future<TypeEnvironment> create(String source) {
     var uri = new Uri(scheme: 'source');
     MockCompiler compiler = compilerFor('''
         main() {}
@@ -30,8 +31,9 @@ class TypeEnvironment {
         uri,
         analyzeAll: true,
         analyzeOnly: true);
-    compiler.runCompiler(uri);
-    return new TypeEnvironment._(compiler);
+    return compiler.runCompiler(uri).then((_) {
+      return new TypeEnvironment._(compiler);
+    });
   }
 
   TypeEnvironment._(MockCompiler this.compiler);
diff --git a/tests/compiler/dart2js/type_variable_bound_test.dart b/tests/compiler/dart2js/type_variable_bound_test.dart
index 01761c49948..5c9b720dce5 100644
--- a/tests/compiler/dart2js/type_variable_bound_test.dart
+++ b/tests/compiler/dart2js/type_variable_bound_test.dart
@@ -2,110 +2,113 @@
 // 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.
 
+import 'dart:async';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 import "package:expect/expect.dart";
 
-compile(String source) {
+Future compile(String source) {
   Uri uri = Uri.parse('test:code');
   var compiler = compilerFor(source, uri);
-  compiler.runCompiler(uri);
-  return compiler;
+  return compiler.runCompiler(uri).then((_) {
+    return compiler;
+  });
 }
 
 test1() {
-  var compiler = compile(r"""
+  asyncTest(() => compile(r"""
 class A<T extends T> {}
 
 void main() {
   new A();
 }
-""");
+""").then((compiler) {
+    Expect.isFalse(compiler.compilationFailed);
+    Expect.isTrue(compiler.errors.isEmpty,
+                  'unexpected errors: ${compiler.errors}');
+    Expect.equals(1, compiler.warnings.length,
+                  'expected exactly one warning, but got ${compiler.warnings}');
 
-  Expect.isFalse(compiler.compilationFailed);
-  Expect.isTrue(compiler.errors.isEmpty,
-                'unexpected errors: ${compiler.errors}');
-  Expect.equals(1, compiler.warnings.length,
-                'expected exactly one warning, but got ${compiler.warnings}');
-
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[0].message.kind);
-  Expect.equals("T", compiler.warnings[0].node.toString());
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[0].message.kind);
+    Expect.equals("T", compiler.warnings[0].node.toString());
+  }));
 }
 
 test2() {
-  var compiler = compile(r"""
+  asyncTest(() => compile(r"""
 class B<T extends S, S extends T> {}
 
 void main() {
   new B();
 }
-""");
+""").then((compiler) {
+    Expect.isFalse(compiler.compilationFailed);
+    print(compiler.errors);
+    Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
+    Expect.equals(2, compiler.warnings.length,
+                  'expected exactly one error, but got ${compiler.warnings}');
 
-  Expect.isFalse(compiler.compilationFailed);
-  print(compiler.errors);
-  Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
-  Expect.equals(2, compiler.warnings.length,
-                'expected exactly one error, but got ${compiler.warnings}');
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[0].message.kind);
+    Expect.equals("T", compiler.warnings[0].node.toString());
 
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[0].message.kind);
-  Expect.equals("T", compiler.warnings[0].node.toString());
-
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[1].message.kind);
-  Expect.equals("S", compiler.warnings[1].node.toString());
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[1].message.kind);
+    Expect.equals("S", compiler.warnings[1].node.toString());
+  }));
 }
 
 test3() {
-  var compiler = compile(r"""
+  asyncTest(() => compile(r"""
 class C<T extends S, S extends U, U extends T> {}
 
 void main() {
   new C();
 }
-""");
+""").then((compiler) {
+    Expect.isFalse(compiler.compilationFailed);
+    print(compiler.errors);
+    Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
+    Expect.equals(3, compiler.warnings.length,
+                  'expected exactly one error, but got ${compiler.warnings}');
 
-  Expect.isFalse(compiler.compilationFailed);
-  print(compiler.errors);
-  Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
-  Expect.equals(3, compiler.warnings.length,
-                'expected exactly one error, but got ${compiler.warnings}');
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[0].message.kind);
+    Expect.equals("T", compiler.warnings[0].node.toString());
 
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[0].message.kind);
-  Expect.equals("T", compiler.warnings[0].node.toString());
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[1].message.kind);
+    Expect.equals("S", compiler.warnings[1].node.toString());
 
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[1].message.kind);
-  Expect.equals("S", compiler.warnings[1].node.toString());
-
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[2].message.kind);
-  Expect.equals("U", compiler.warnings[2].node.toString());
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[2].message.kind);
+    Expect.equals("U", compiler.warnings[2].node.toString());
+  }));
 }
 
 test4() {
-  var compiler = compile(r"""
+  asyncTest(() => compile(r"""
 class D<T extends S, S extends U, U extends S> {}
 
 void main() {
   new D();
 }
-""");
+""").then((compiler) {
+    Expect.isFalse(compiler.compilationFailed);
+    print(compiler.errors);
+    Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
+    Expect.equals(2, compiler.warnings.length,
+                  'expected exactly one error, but got ${compiler.warnings}');
 
-  Expect.isFalse(compiler.compilationFailed);
-  print(compiler.errors);
-  Expect.isTrue(compiler.errors.isEmpty, 'unexpected errors');
-  Expect.equals(2, compiler.warnings.length,
-                'expected exactly one error, but got ${compiler.warnings}');
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[0].message.kind);
+    Expect.equals("S", compiler.warnings[0].node.toString());
 
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[0].message.kind);
-  Expect.equals("S", compiler.warnings[0].node.toString());
-
-  Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
-                compiler.warnings[1].message.kind);
-  Expect.equals("U", compiler.warnings[1].node.toString());
+    Expect.equals(MessageKind.CYCLIC_TYPE_VARIABLE,
+                  compiler.warnings[1].message.kind);
+    Expect.equals("U", compiler.warnings[1].node.toString());
+  }));
 }
 
 main() {
diff --git a/tests/compiler/dart2js/type_variable_occurrence_test.dart b/tests/compiler/dart2js/type_variable_occurrence_test.dart
index c9a28b979a8..1d51adf4fd0 100644
--- a/tests/compiler/dart2js/type_variable_occurrence_test.dart
+++ b/tests/compiler/dart2js/type_variable_occurrence_test.dart
@@ -5,6 +5,7 @@
 library subtype_test;
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
@@ -15,7 +16,7 @@ void main() {
 }
 
 testTypeVariableOccurrence() {
-  var env = new TypeEnvironment(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       typedef S Typedef1<S>();
       typedef void Typedef2<S>(S s);
       typedef void Typedef3<S>(A<S> a);
@@ -27,7 +28,7 @@ testTypeVariableOccurrence() {
         A<T> field4;
         A<A<int>> field5;
         A<A<T>> field6;
-    
+
         Typedef1 field7;
         Typedef1<int> field8;
         Typedef1<T> field9;
@@ -52,77 +53,77 @@ testTypeVariableOccurrence() {
         void method7([T t]) {}
         void method8({T t}) {}
       }
-      """);
+      """).then((env) {
 
-  ClassElement A = env.getElement('A');
+    ClassElement A = env.getElement('A');
 
-  expect(bool expect, String memberName) {
-    DartType memberType = env.getMemberType(A, memberName);
-    TypeVariableType typeVariable = memberType.typeVariableOccurrence;
-    if (expect) {
-      Expect.isNotNull(typeVariable);
-      Expect.equals(A, Types.getClassContext(memberType));
-    } else {
-      Expect.isNull(typeVariable);
-      Expect.isNull(Types.getClassContext(memberType));
+    expect(bool expect, String memberName) {
+      DartType memberType = env.getMemberType(A, memberName);
+      TypeVariableType typeVariable = memberType.typeVariableOccurrence;
+      if (expect) {
+        Expect.isNotNull(typeVariable);
+        Expect.equals(A, Types.getClassContext(memberType));
+      } else {
+        Expect.isNull(typeVariable);
+        Expect.isNull(Types.getClassContext(memberType));
+      }
     }
-  }
 
-  // int field1;
-  expect(false, 'field1');
-  // T field2;
-  expect(true, 'field2');
-  // A<int> field3;
-  expect(false, 'field3');
-  // A<T> field4;
-  expect(true, 'field4');
-  // A<A<int>> field5;
-  expect(false, 'field5');
-  // A<A<T>> field6;
-  expect(true, 'field6');
+    // int field1;
+    expect(false, 'field1');
+    // T field2;
+    expect(true, 'field2');
+    // A<int> field3;
+    expect(false, 'field3');
+    // A<T> field4;
+    expect(true, 'field4');
+    // A<A<int>> field5;
+    expect(false, 'field5');
+    // A<A<T>> field6;
+    expect(true, 'field6');
 
-  // Typedef1 field7;
-  expect(false, 'field7');
-  // Typedef1<int> field8;
-  expect(false, 'field8');
-  // Typedef1<T> field9;
-  expect(true, 'field9');
-  // Typedef1<Typedef1<T>> field10;
-  expect(true, 'field10');
+    // Typedef1 field7;
+    expect(false, 'field7');
+    // Typedef1<int> field8;
+    expect(false, 'field8');
+    // Typedef1<T> field9;
+    expect(true, 'field9');
+    // Typedef1<Typedef1<T>> field10;
+    expect(true, 'field10');
 
-  // Typedef2 field11;
-  expect(false, 'field11');
-  // Typedef2<int> field12;
-  expect(false, 'field12');
-  // Typedef2<T> field13;
-  expect(true, 'field13');
-  // Typedef2<Typedef1<T>> field14;
-  expect(true, 'field14');
+    // Typedef2 field11;
+    expect(false, 'field11');
+    // Typedef2<int> field12;
+    expect(false, 'field12');
+    // Typedef2<T> field13;
+    expect(true, 'field13');
+    // Typedef2<Typedef1<T>> field14;
+    expect(true, 'field14');
 
-  // Typedef3 field15;
-  expect(false, 'field15');
-  // Typedef3<int> field16;
-  expect(false, 'field16');
-  // Typedef3<T> field17;
-  expect(true, 'field17');
-  // Typedef3<Typedef1<T>> field18;
-  expect(true, 'field18');
-
-  // void method1() {}
-  expect(false, 'method1');
-  // T method2() => null;
-  expect(true, 'method2');
-  // A<T> method3() => null;
-  expect(true, 'method3');
-  // void method4(T t) {}
-  expect(true, 'method4');
-  // void method5(A<T> t) {}
-  expect(true, 'method5');
-  // void method6(void foo(T t)) {}
-  expect(true, 'method6');
-  // void method7([T t]);
-  expect(true, 'method7');
-  // void method8({T t});
-  expect(true, 'method8');
+    // Typedef3 field15;
+    expect(false, 'field15');
+    // Typedef3<int> field16;
+    expect(false, 'field16');
+    // Typedef3<T> field17;
+    expect(true, 'field17');
+    // Typedef3<Typedef1<T>> field18;
+    expect(true, 'field18');
 
+    // void method1() {}
+    expect(false, 'method1');
+    // T method2() => null;
+    expect(true, 'method2');
+    // A<T> method3() => null;
+    expect(true, 'method3');
+    // void method4(T t) {}
+    expect(true, 'method4');
+    // void method5(A<T> t) {}
+    expect(true, 'method5');
+    // void method6(void foo(T t)) {}
+    expect(true, 'method6');
+    // void method7([T t]);
+    expect(true, 'method7');
+    // void method8({T t});
+    expect(true, 'method8');
+  }));
 }
diff --git a/tests/compiler/dart2js/types_of_captured_variables_test.dart b/tests/compiler/dart2js/types_of_captured_variables_test.dart
index 3376b657066..9e802bd153a 100644
--- a/tests/compiler/dart2js/types_of_captured_variables_test.dart
+++ b/tests/compiler/dart2js/types_of_captured_variables_test.dart
@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'compiler_helper.dart';
 
 const String TEST1 = r"""
@@ -35,15 +36,18 @@ main() {
 
 main() {
   // Test that we know the type of captured, non-mutated variables.
-  String generated = compileAll(TEST1);
-  Expect.isTrue(generated.contains('+ 3'));
+  asyncTest(() => compileAll(TEST1).then((generated) {
+    Expect.isTrue(generated.contains('+ 3'));
+  }));
 
   // Test that we know the type of captured, mutated variables.
-  generated = compileAll(TEST2);
-  Expect.isTrue(generated.contains('+ 3'));
+  asyncTest(() => compileAll(TEST2).then((generated) {
+    Expect.isTrue(generated.contains('+ 3'));
+  }));
 
   // Test that we know when types of a captured, mutated variable
   // conflict.
-  generated = compileAll(TEST3);
-  Expect.isFalse(generated.contains('+ 3'));
+  asyncTest(() => compileAll(TEST3).then((generated) {
+    Expect.isFalse(generated.contains('+ 3'));
+  }));
 }
diff --git a/tests/compiler/dart2js/unneeded_part_js_test.dart b/tests/compiler/dart2js/unneeded_part_js_test.dart
index cebcd910516..c8c0f201801 100644
--- a/tests/compiler/dart2js/unneeded_part_js_test.dart
+++ b/tests/compiler/dart2js/unneeded_part_js_test.dart
@@ -5,6 +5,7 @@
 // Test that no parts are emitted when deferred loading isn't used.
 
 import 'package:expect/expect.dart';
+import "package:async_helper/async_helper.dart";
 import 'memory_source_file_helper.dart';
 
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart'
@@ -20,8 +21,7 @@ main() {
   Uri libraryRoot = script.resolve('../../../sdk/');
   Uri packageRoot = script.resolve('./packages/');
 
-  MemorySourceFileProvider.MEMORY_SOURCE_FILES = MEMORY_SOURCE_FILES;
-  var provider = new MemorySourceFileProvider();
+  var provider = new MemorySourceFileProvider(MEMORY_SOURCE_FILES);
   void diagnosticHandler(Uri uri, int begin, int end,
                          String message, Diagnostic kind) {
     if (kind == Diagnostic.VERBOSE_INFO) {
@@ -41,8 +41,9 @@ main() {
                                    libraryRoot,
                                    packageRoot,
                                    []);
-  compiler.run(Uri.parse('memory:main.dart'));
-  Expect.isFalse(compiler.compilationFailed);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    Expect.isFalse(compiler.compilationFailed);
+  }));
 }
 
 const Map MEMORY_SOURCE_FILES = const {
diff --git a/tests/utils/dummy_compiler_test.dart b/tests/utils/dummy_compiler_test.dart
index 5c7c1dae6b6..be633462bb6 100644
--- a/tests/utils/dummy_compiler_test.dart
+++ b/tests/utils/dummy_compiler_test.dart
@@ -8,6 +8,7 @@
 library dummy_compiler;
 
 import 'dart:async';
+import "package:async_helper/async_helper.dart";
 
 import '../../sdk/lib/_internal/compiler/compiler.dart';
 
@@ -102,6 +103,7 @@ void handler(Uri uri, int begin, int end, String message, Diagnostic kind) {
 }
 
 main() {
+  asyncStart();
   Future<String> result =
       compile(new Uri(scheme: 'main'),
               new Uri(scheme: 'lib', path: '/'),
@@ -113,5 +115,5 @@ main() {
     }
   }, onError: (e) {
       throw 'Compilation failed';
-  });
+  }).whenComplete(() => asyncEnd());
 }
diff --git a/tests/utils/recursive_import_test.dart b/tests/utils/recursive_import_test.dart
index b0a042dfcad..0bb8769d9cd 100644
--- a/tests/utils/recursive_import_test.dart
+++ b/tests/utils/recursive_import_test.dart
@@ -5,6 +5,7 @@
 // Test of "recursive" imports using the dart2js compiler API.
 
 import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
 import 'dart:async';
 import '../../sdk/lib/_internal/compiler/compiler.dart';
 
@@ -90,7 +91,7 @@ main() {
         source = "library lib${uri.path.replaceAll('/', '.')};";
       }
     } else {
-     throw "unexpected URI $uri";
+     return new Future.error("unexpected URI $uri");
     }
     return new Future.value(source);
   }
@@ -111,6 +112,7 @@ main() {
     }
   }
 
+  asyncStart();
   Future<String> result =
       compile(new Uri(scheme: 'main'),
               new Uri(scheme: 'lib', path: '/'),
@@ -125,5 +127,5 @@ main() {
     Expect.equals(1, errorCount);
   }, onError: (e) {
       throw 'Compilation failed';
-  });
+  }).whenComplete(() => asyncEnd());
 }