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

pkg/kernel/lib/transformations/insert_covariance_checks.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.insert_covariance_checks;
 
 import '../class_hierarchy.dart';
 import '../clone.dart';
 import '../core_types.dart';
 import '../kernel.dart';
 import '../log.dart';
@@ skipping 35 matching lines @@
 /// the type argument is exact.  For example:
 ///
 ///     void foo(List<num> numbers) {
 ///       numbers.add(3.5); // before
 ///       numbers.add$cc(3.5); // after
 ///     }
 ///
 /// Currently, we only deduce that the type arguments are exact when the
 /// receiver is `this`.
 class InsertCovarianceChecks {
+  final CoreTypes coreTypes;
   ClassHierarchy hierarchy;
-  CoreTypes coreTypes;
   TypeEnvironment types;
 
   /// Maps unsafe members to their checked entry point, to be used at call sites
   /// where the arguments cannot be guaranteed to satisfy the generic parameter
   /// types of the actual target.
   final Map<Member, Procedure> unsafeMemberEntryPoint = <Member, Procedure>{};
 
   /// Members that may be invoked through a checked entry point.
   ///
   /// Note that these members are not necessarily unsafe, because a safe member
   /// can override an unsafe member, and thereby be invoked through a checked
   /// entry point.  This set is not therefore not the same as the set of keys
   /// in [unsafeMemberEntryPoint].
   final Set<Member> membersWithCheckedEntryPoint = new Set<Member>();
 
-  InsertCovarianceChecks({this.hierarchy, this.coreTypes});
+  InsertCovarianceChecks(this.coreTypes, {this.hierarchy});
 
   void transformProgram(Program program) {
     hierarchy ??= new ClassHierarchy(program);
-    coreTypes ??= new CoreTypes(program);
     types = new TypeEnvironment(coreTypes, hierarchy);
     // We transform every class before their subtypes.
     // This ensures that transitive overrides are taken into account.
     hierarchy.classes.forEach(transformClass);
 
     program.accept(new _CallTransformer(this));
   }
 
   void transformClass(Class class_) {
     new _ClassTransformer(class_, this).transformClass();
@@ skipping 428 matching lines @@
   @override
   visitPropertySet(PropertySet node) {
     var target = getChecked(node.receiver, node.interfaceTarget);
     if (target != null) {
       node.interfaceTarget = target;
       node.name = target.name;
     }
     node.visitChildren(this);
   }
 }