Transform async code only for source libraries.

pkg/kernel/lib/transformations/continuation.dart

 // Copyright (c) 2016, 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 kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../core_types.dart';
 import '../visitor.dart';
 
 import 'async.dart';
 
+void transformLibraries(CoreTypes coreTypes, List<Library> libraries) {
+  var helper = new HelperNodes.fromCoreTypes(coreTypes);
+  var rewriter = new RecursiveContinuationRewriter(helper);
+  for (var library in libraries) {
+    rewriter.rewriteLibrary(library);
+  }
+}
+
 Program transformProgram(Program program) {
   var helper = new HelperNodes.fromProgram(program);
   var rewriter = new RecursiveContinuationRewriter(helper);
   return rewriter.rewriteProgram(program);
 }
 
 class RecursiveContinuationRewriter extends Transformer {
   final HelperNodes helper;
   final VariableDeclaration asyncJumpVariable = new VariableDeclaration(
       ":await_jump_var",
       initializer: new IntLiteral(0));
   final VariableDeclaration asyncContextVariable =
       new VariableDeclaration(":await_ctx_var");
 
   RecursiveContinuationRewriter(this.helper);
 
   Program rewriteProgram(Program node) {
     return node.accept(this);
   }
 
+  Library rewriteLibrary(Library node) {
+    return node.accept(this);
+  }
+
   visitFunctionNode(FunctionNode node) {
     switch (node.asyncMarker) {
       case AsyncMarker.Sync:
       case AsyncMarker.SyncYielding:
         node.transformChildren(new RecursiveContinuationRewriter(helper));
         return node;
       case AsyncMarker.SyncStar:
         return new SyncStarFunctionRewriter(helper, node).rewrite();
       case AsyncMarker.Async:
         return new AsyncFunctionRewriter(helper, node).rewrite();
@@ skipping 860 matching lines @@
       this.completerConstructor,
       this.syncIterableConstructor,
       this.streamIteratorConstructor,
       this.futureMicrotaskConstructor,
       this.streamControllerConstructor,
       this.asyncThenWrapper,
       this.asyncErrorWrapper,
       this.awaitHelper,
       this.coreTypes);
 
-  factory HelperNodes.fromProgram(Program program) {
-    var coreTypes = new CoreTypes(program);
+  factory HelperNodes.fromCoreTypes(CoreTypes coreTypes) {
     return new HelperNodes(
         coreTypes.asyncLibrary,
         coreTypes.coreLibrary,
         coreTypes.iteratorClass,
         coreTypes.futureClass,
         coreTypes.futureOrClass,
         coreTypes.completerClass,
         coreTypes.printProcedure,
         coreTypes.completerSyncConstructor,
         coreTypes.syncIterableDefaultConstructor,
         coreTypes.streamIteratorDefaultConstructor,
         coreTypes.futureMicrotaskConstructor,
         coreTypes.asyncStarStreamControllerDefaultConstructor,
         coreTypes.asyncThenWrapperHelperProcedure,
         coreTypes.asyncErrorWrapperHelperProcedure,
         coreTypes.awaitHelperProcedure,
         coreTypes);
   }
+
+  factory HelperNodes.fromProgram(Program program) {
+    var coreTypes = new CoreTypes(program);
+    return new HelperNodes.fromCoreTypes(coreTypes);
+  }
 }