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.
+  /// Given the [unordered] classes, return them in such order that classes
+  /// occur after their super classes.
   ///
-  /// The iterable is ordered so that classes occur after their super classes.
-  Iterable<Class> get classes;
+  /// If [unordered] does not include all superclasses, they might still be
+  /// returned, it is up to the client to filter them out if required.
+  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) => classes;

[Siggi Cherem (dart-lang), 2017/06/06 00:15:21]

mmm - It seems a bit surprising if you pass 2 classes in and the result has all
classes in the program too (not just the extra classes from supertypes).

We should at least mention it in the doc above, but I might prefer using 2 APIs
here:
  - make `getOrderedClasses` filter the result based on what was passed in (this
would not be needed in the incremental implementation, only here)
  - keep the `classes` API, but implement it on the incremental version by
forcing all classes to be created at that moment (like the eager implementation
does at construction or like you did in the transformer)

[scheglov, 2017/06/06 01:33:27]

I updated `getOrderedClasses` to perform filtering.

The only client of `getOrderedClasses` which is not obviously whole-program
transformation is `InsertCovarianceChecks`.

All the other clients work over whole programs, and can continue using
`ClosedWorldClassHierarchy.classes`, even if it is not API of `ClassHierarchy`.

There is no such thing as "all classes" in `IncrementalClassHierarchy` - we
build only what we were asked about.

[Siggi Cherem (dart-lang), 2017/06/06 03:03:44]

sorry, makes sense,  I forgot that  IncrementalClassHierarchy never takes a
program

+
   /// 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;
   }
 }