Replace ClassHierarchy.classes with getOrderedClasses().

pkg/kernel/lib/class_hierarchy.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.class_hierarchy;
 
 import 'ast.dart';
 import 'dart:math';
 import 'dart:typed_data';
 import 'src/heap.dart';
 import 'type_algebra.dart';
 
 /// Interface for answering various subclassing queries.
 /// TODO(scheglov) Several methods are not used, or used only in tests.
 /// Check if these methods are not useful and should be removed .
 abstract class ClassHierarchy {
   factory ClassHierarchy(Program program) =>
       new ClosedWorldClassHierarchy(program);
 
-  /// All classes in the program.
-  ///
-  /// The iterable is ordered so that classes occur after their super classes.
-  Iterable<Class> get classes;
+  /// Given the [unordered] classes, return them in such order that classes
+  /// occur after their superclasses.  If some superclasses are not in
+  /// [unordered], they are not included.
+  Iterable<Class> getOrderedClasses(Iterable<Class> unordered);
 
-  /// Returns the index of [class_] in the [classes] list.
+  /// Returns the unique index of the [class_].
   int getClassIndex(Class class_);
 
   /// True if the program contains another class that is a subtype of given one.
   bool hasProperSubtypes(Class class_);
 
   /// Returns the number of steps in the longest inheritance path from [class_]
   /// to [Object].
   int getClassDepth(Class class_);
 
   /// Returns a list of classes appropriate for use in calculating a least upper
@@ skipping 95 matching lines @@
   final List<Class> classes;
 
   final Map<Class, _ClassInfo> _infoFor = <Class, _ClassInfo>{};
 
   ClosedWorldClassHierarchy(Program program)
       : this._internal(program, _countClasses(program));
 
   @override
   int getClassIndex(Class class_) => _infoFor[class_].topologicalIndex;
 
+  @override
+  Iterable<Class> getOrderedClasses(Iterable<Class> unordered) {
+    var unorderedSet = unordered.toSet();
+    return classes.where(unorderedSet.contains);
+  }
+
   /// True if [subclass] inherits from [superclass] though zero or more
   /// `extends` relationships.
   bool isSubclassOf(Class subclass, Class superclass) {
     if (identical(subclass, superclass)) return true;
     return _infoFor[subclass].isSubclassOf(_infoFor[superclass]);
   }
 
   /// True if [submixture] inherits from [superclass] though zero or more
   /// `extends` and `with` relationships.
   bool isSubmixtureOf(Class submixture, Class superclass) {
@@ skipping 962 matching lines @@
 class _LubHeap extends Heap<_ClassInfo> {
   @override
   bool sortsBefore(_ClassInfo a, _ClassInfo b) => sortsBeforeStatic(a, b);
 
   static bool sortsBeforeStatic(_ClassInfo a, _ClassInfo b) {
     if (a.depth > b.depth) return true;
     if (a.depth < b.depth) return false;
     return a.topologicalIndex < b.topologicalIndex;
   }
 }