Don't recreate CoreTypes in transformers. Pass it in.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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 fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File;
 
@@ skipping 22 matching lines @@
         Program,
         Source,
         StringLiteral,
         SuperInitializer,
         Throw,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
-import 'package:kernel/core_types.dart' show CoreTypes;
 import 'package:kernel/transformations/erasure.dart' show Erasure;
 
 import 'package:kernel/transformations/continuation.dart' as transformAsync;
 
 import 'package:kernel/transformations/mixin_full_resolution.dart' as mix;
 
 import 'package:kernel/type_algebra.dart' show substitute;
 
 import '../source/source_loader.dart' show SourceLoader;
 
@@ skipping 599 matching lines @@
   }
 
   /// Run all transformations that are needed when building a program for the
   /// first time.
   void runBuildTransformations() {
     transformMixinApplications();
     otherTransformations();
   }
 
   void transformMixinApplications() {
-    mix.transformLibraries(backendTarget, loader.libraries);
+    mix.transformLibraries(backendTarget, loader.coreTypes, loader.libraries);
     ticker.logMs("Transformed mixin applications");
   }
 
   void otherTransformations() {
     // TODO(ahe): Don't generate type variables in the first place.
     if (!strongMode) {
       _program.accept(new Erasure());
       ticker.logMs("Erased type variables in generic methods");
     }
-    var coreTypes = new CoreTypes(_program);
     // TODO(kmillikin): Make this run on a per-method basis.
-    transformAsync.transformLibraries(coreTypes, loader.libraries);
+    transformAsync.transformLibraries(loader.coreTypes, loader.libraries);
     ticker.logMs("Transformed async methods");
   }
 
   void verify() {
     var verifyErrors = verifyProgram(_program);
     errors.addAll(verifyErrors.map((error) => '$error'));
     ticker.logMs("Verified program");
   }
 
   /// Tree-shakes most code from the [dillTarget] by visiting all other
   /// libraries in [_program] and marking the APIs from the [dillTarget]
   /// libraries that are in use.
   ///
   /// Note: while it's likely we'll do some trimming of programs for modular
   /// compilation, it is unclear at this time when and how that trimming should
   /// happen. We are likely going to remove the extra visitor my either marking
   /// things while code is built, or by handling tree-shaking after the fact
   /// (e.g. during serialization).
   trimDependenciesInProgram() {
     var toShake =
         dillTarget.loader.libraries.map((lib) => lib.importUri).toSet();
     var isIncluded = (Uri uri) => !toShake.contains(uri);
     var data = new RetainedDataBuilder();
     // TODO(sigmund): replace this step with data that is directly computed from
     // the builders: we should know the tree-shaking roots without having to do
     // a second visit over the tree.
-    new RootsMarker(data).run(_program, isIncluded);
+    new RootsMarker(loader.coreTypes, data).run(_program, isIncluded);
     trimProgram(_program, data, isIncluded);
   }
 
   /// Return `true` if the given [library] was built by this [KernelTarget]
   /// from sources, and not loaded from a [DillTarget].
   bool isSourceLibrary(Library library) {
     return loader.libraries.contains(library);
   }
 }
 
 /// Looks for a constructor call that matches `super()` from a constructor in
 /// [cls]. Such a constructor may have optional arguments, but no required
 /// arguments.
 Constructor defaultSuperConstructor(Class cls) {
   Class superclass = cls.superclass;
   while (superclass != null && superclass.isMixinApplication) {
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }