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';
 
-Program transformProgram(Program program) {
+Program transformProgram(Program program,

[Siggi Cherem (dart-lang), 2017/05/23 22:06:17]

API design question for Kevin/Peter:

Would you rather have:
  Program transformProgram(Program program, filter);

Or

  void transformLibraries(List<Library> libraries);


I'm fine with either at this time, but have a slight preference for the latter
when it comes to modular transformations: you don't need a program if you are
applying a modular transformation.

(this relates to my general comment on the CL, we'll have similar API choice
when we switch to use Target.performModularTransformations.)

+    {bool libraryFilter(Library library)}) {
   var helper = new HelperNodes.fromProgram(program);
   var rewriter = new RecursiveContinuationRewriter(helper);
-  return rewriter.rewriteProgram(program);
+  for (var library in program.libraries) {
+    if (libraryFilter == null || libraryFilter(library)) {
+      rewriter.rewriteLibrary(library);
+    }
+  }
+  return 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 881 matching lines @@
         coreTypes.syncIterableDefaultConstructor,
         coreTypes.streamIteratorDefaultConstructor,
         coreTypes.futureMicrotaskConstructor,
         coreTypes.asyncStarStreamControllerDefaultConstructor,
         coreTypes.asyncThenWrapperHelperProcedure,
         coreTypes.asyncErrorWrapperHelperProcedure,
         coreTypes.awaitHelperProcedure,
         coreTypes);
   }
 }