Pass ClassHierarchy instead of creating it.

pkg/kernel/lib/transformations/treeshaker.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.tree_shaker;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../core_types.dart';
 import '../type_environment.dart';
 import '../library_index.dart';
 
-Program transformProgram(CoreTypes coreTypes, Program program,
+Program transformProgram(
+    CoreTypes coreTypes, ClassHierarchy hierarchy, Program program,
     {List<ProgramRoot> programRoots}) {
-  new TreeShaker(coreTypes, program, programRoots: programRoots)
+  new TreeShaker(coreTypes, hierarchy, program, programRoots: programRoots)
       .transform(program);
   return program;
 }
 
 enum ProgramRootKind {
   /// The root is a class which will be instantiated by
   /// external / non-Dart code.
   ExternallyInstantiatedClass,
 
   /// The root is a setter function or a field.
@@ skipping 57 matching lines @@
 ///
 /// The tree shaker computes the following in a fixed-point iteration:
 /// - a set of instantiated classes
 /// - for each member, a set of potential host classes
 /// - a set of names used in dynamic dispatch not on `this`
 ///
 /// If the `dart:mirrors` library is used then nothing will be tree-shaken.
 //
 // TODO(asgerf): Tree shake unused instance fields.
 class TreeShaker {
+  final CoreTypes coreTypes;
+  final ClosedWorldClassHierarchy hierarchy;
   final Program program;
-  final ClosedWorldClassHierarchy hierarchy;
-  final CoreTypes coreTypes;
   final bool strongMode;
   final List<ProgramRoot> programRoots;
 
   /// Map from classes to set of names that have been dispatched with that class
   /// as the static receiver type (meaning any subtype of that class can be
   /// the potential concrete receiver).
   ///
   /// The map is implemented as a list, indexed by
   /// [ClassHierarchy.getClassIndex].
   final List<Set<Name>> _dispatchedNames;
@@ skipping 56 matching lines @@
 
   Library _mirrorsLibrary;
 
   /// Set to true if any use of the `dart:mirrors` API is found.
   bool isUsingMirrors = false;
 
   /// If we have roots, we will shake, even if we encounter some elements from
   /// the mirrors library.
   bool get forceShaking => programRoots != null && programRoots.isNotEmpty;
 
-  TreeShaker(CoreTypes coreTypes, Program program,
-      {ClassHierarchy hierarchy,
-      bool strongMode: false,
-      List<ProgramRoot> programRoots})
-      : this._internal(program, hierarchy ?? new ClassHierarchy(program),
-            coreTypes, strongMode, programRoots);
+  TreeShaker(CoreTypes coreTypes, ClassHierarchy hierarchy, Program program,
+      {bool strongMode: false, List<ProgramRoot> programRoots})
+      : this._internal(coreTypes, hierarchy, program, strongMode, programRoots);
 
   bool isMemberBodyUsed(Member member) {
     return _usedMembers.containsKey(member);
   }
 
   bool isMemberOverridden(Member member) {
     return _overriddenMembers.contains(member);
   }
 
   bool isMemberUsed(Member member) {
@@ skipping 14 matching lines @@
   }
 
   /// Applies the tree shaking results to the program.
   ///
   /// This removes unused classes, members, and hierarchy data.
   void transform(Program program) {
     if (isUsingMirrors) return; // Give up if using mirrors.
     new _TreeShakingTransformer(this).transform(program);
   }
 
-  TreeShaker._internal(this.program, ClosedWorldClassHierarchy hierarchy,
-      this.coreTypes, this.strongMode, this.programRoots)
-      : this.hierarchy = hierarchy,
-        this._dispatchedNames = new List<Set<Name>>(hierarchy.classes.length),
+  TreeShaker._internal(this.coreTypes, this.hierarchy, this.program,
+      this.strongMode, this.programRoots)
+      : this._dispatchedNames = new List<Set<Name>>(hierarchy.classes.length),
         this._usedMembersWithHost =
             new List<Set<Member>>(hierarchy.classes.length),
         this._classRetention = new List<ClassRetention>.filled(
             hierarchy.classes.length, ClassRetention.None) {
     _visitor = new _TreeShakerVisitor(this);
     _covariantVisitor = new _ExternalTypeVisitor(this, isCovariant: true);
     _contravariantVisitor =
         new _ExternalTypeVisitor(this, isContravariant: true);
     _invariantVisitor = new _ExternalTypeVisitor(this,
         isCovariant: true, isContravariant: true);
@@ skipping 857 matching lines @@
         classNode == coreTypes.futureClass ||
         classNode == coreTypes.streamClass ||
         classNode == coreTypes.listClass ||
         classNode == coreTypes.mapClass;
   }
 }
 
 /// Exception that is thrown to stop the tree shaking analysis when a use
 /// of `dart:mirrors` is found.
 class _UsingMirrorsException {}