Expose getInterfaceMembers method through ClassHierarchy.

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';
@@ skipping 70 matching lines @@
   /// [name].
   ///
   /// If [setter] is `false`, only fields, methods, and getters with that name
   /// will be found.  If [setter] is `true`, only non-final fields and setters
   /// will be found.
   ///
   /// If multiple members with that name are inherited and not overridden, the
   /// member from the first declared supertype is returned.
   Member getInterfaceMember(Class class_, Name name, {bool setter: false});
 
+  /// Returns the list of members denoting the interface for [class_], which
+  /// may include abstract members.
+  ///
+  /// The list may contain multiple members with a given name.  This happens
+  /// when members are inherited through different supertypes and not overridden
+  /// in the class.
+  ///
+  /// Also see [getInterfaceMember].
+  List<Member> getInterfaceMembers(Class class_, {bool setters: false});
+
   /// Invokes [callback] for every member declared in or inherited by [class_]
   /// that overrides or implements a member in a supertype of [class_]
   /// (or in rare cases, overrides a member declared in [class_]).
   ///
   /// We use the term "inheritable" for members that are candidates for
   /// inheritance but may have been overridden.  The "declared" members of a
   /// mixin application are those declared in the mixed-in type. The callback is
   /// invoked in the following cases:
   ///
   /// 1. A member declared in the class overrides a member inheritable through
@@ skipping 277 matching lines @@
     _ClassInfo info = _infoFor[class_];
     return setters ? info.implementedSetters : info.implementedGettersAndCalls;
   }
 
   @override
   Member getInterfaceMember(Class class_, Name name, {bool setter: false}) {
     List<Member> list = getInterfaceMembers(class_, setters: setter);
     return _findMemberByName(list, name);
   }
 
-  /// Returns the list of members denoting the interface for [class_], which
-  /// may include abstract members.
-  ///
-  /// The list may contain multiple members with a given name.  This happens
-  /// when members are inherited through different supertypes and not overridden
-  /// in the class.
-  ///
-  /// Also see [getInterfaceMember].
+  @override
   List<Member> getInterfaceMembers(Class class_, {bool setters: false}) {
     return _buildInterfaceMembers(class_, _infoFor[class_], setters: setters);
   }
 
   @override
   void forEachOverridePair(Class class_,
       callback(Member declaredMember, Member interfaceMember, bool isSetter),
       {bool crossGettersSetters: false}) {
     _ClassInfo info = _infoFor[class_];
     for (var supertype in class_.supers) {
@@ skipping 762 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;
   }
 }