Transform async code only for source libraries.

pkg/front_end/lib/src/incremental_kernel_generator_impl.dart

 // Copyright (c) 2017, 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:front_end/file_system.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/src/base/api_signature.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/translate_uri.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
+import 'package:kernel/ast.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
 import 'package:kernel/binary/ast_to_binary.dart';
 import 'package:kernel/kernel.dart' hide Source;
+import 'package:kernel/transformations/continuation.dart' as transformAsync;
+import 'package:kernel/transformations/erasure.dart' as transformErasure;
+import 'package:kernel/transformations/mixin_full_resolution.dart'
+    as transformMixin;
 
 dynamic unimplemented() {
   // TODO(paulberry): get rid of this.
   throw new UnimplementedError();
 }
 
 class ByteSink implements Sink<List<int>> {
   final BytesBuilder builder = new BytesBuilder();
 
   void add(List<int> data) {
@@ skipping 163 matching lines @@
           var reader = new BinaryBuilder(bytes);
           reader.readProgram(program);
 
           await appendNewDillLibraries(program);
 
           return new _LibraryCycleResult(cycle, signature, program.libraries);
         });
       }
 
       // Create KernelTarget and configure it for compiling the cycle URIs.
-      KernelTarget kernelTarget = new KernelTarget(_fsState.fileSystemView,
+      var kernelTarget = new _IncrementalKernelTarget(_fsState.fileSystemView,
           dillTarget, _uriTranslator, _options.strongMode);
       for (FileState library in cycle.libraries) {
         kernelTarget.read(library.uri);
       }
 
       // Compile the cycle libraries into a new full program.
       Program program = await _logger
           .runAsync('Compile ${cycle.libraries.length} libraries', () async {
         await kernelTarget.buildOutlines(nameRoot: nameRoot);
         return await kernelTarget.buildProgram();
@@ skipping 66 matching lines @@
   }
 
   List<int> _writeProgramBytes(Program program, bool filter(Library library)) {
     ByteSink byteSink = new ByteSink();
     new LibraryFilteringBinaryPrinter(byteSink, filter)
         .writeProgramFile(program);
     return byteSink.builder.takeBytes();
   }
 }
 
+class _IncrementalKernelTarget extends KernelTarget {
+  _IncrementalKernelTarget(FileSystem fileSystem, DillTarget dillTarget,
+      TranslateUri uriTranslator, bool strongMode)
+      : super(fileSystem, dillTarget, uriTranslator, strongMode);
+
+  @override
+  void runBuildTransformations() {

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

Not sure if we need this subclass: even outside the incremental generator, I
believe we should only apply transformations to sourcelibraries and not to code
loaded from the dillTarget (since we overall expect the dillTarget to only have
outlines anyways)

I'd be inclined to simply modify the call to transformProgram directly in
KernelTarget. Peter - do you agree?

+    // TODO(scheglov) apply only to source libraries
+    new transformMixin.MixinFullResolution(backendTarget).transform(program);
+    if (!strongMode) {
+      program.accept(new transformErasure.Erasure());
+    }
+    // Transform only source libraries.
+    // Dill libraries have already been transformed.
+    transformAsync.transformProgram(program, libraryFilter: isSourceLibrary);
+  }
+}
+
 /// Compilation result for a library cycle.
 class _LibraryCycleResult {
   final LibraryCycle cycle;
 
   /// The signature of the result.
   ///
   /// Currently it is based on the full content of the transitive closure of
   /// the [cycle] files and all its dependencies.
   /// TODO(scheglov) Not used yet.
   /// TODO(scheglov) Use API signatures.
   /// TODO(scheglov) Or use tree shaking and compute signatures of outlines.
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   _LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }