Fix forEachOverridePair in the case where the class in question is abstract.

pkg/kernel/test/class_hierarchy_test.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/src/incremental_class_hierarchy.dart';
 import 'package:kernel/testing/mock_sdk_program.dart';
 import 'package:kernel/text/ast_to_text.dart';
@@ skipping 270 matching lines @@
 }
 class C extends self::A implements self::B {}
 class D {}
 class E = self::D with self::A implements self::B {}
 ''');
 
     _assertOverridePairs(c, ['test::A::foo overrides test::B::foo']);
     _assertOverridePairs(e, ['test::A::foo overrides test::B::foo']);
   }
 
+  /// An abstract member declared in the class is overridden by a member in
+  /// one of the interfaces.
+  void test_forEachOverridePair_supertypeOverridesThis() {
+    var a = addClass(new Class(
+        name: 'A',
+        supertype: objectSuper,
+        procedures: [newEmptyMethod('foo')]));
+    var b = addClass(new Class(
+        name: 'B',
+        supertype: a.asThisSupertype,
+        procedures: [newEmptyMethod('foo', isAbstract: true)]));
+    var c = addClass(new Class(
+        name: 'C',
+        supertype: a.asThisSupertype,
+        procedures: [newEmptyMethod('foo', isAbstract: true)],
+        isAbstract: true));
+
+    _assertTestLibraryText('''
+class A {
+  method foo() → void {}
+}
+class B extends self::A {
+  abstract method foo() → void;
+}
+abstract class C extends self::A {
+  abstract method foo() → void;
+}
+''');
+
+    _assertOverridePairs(b, [
+      'test::A::foo overrides test::B::foo',
+      'test::B::foo overrides test::A::foo'
+    ]);
+    _assertOverridePairs(c, [
+      'test::A::foo overrides test::C::foo',
+      'test::C::foo overrides test::A::foo'
+    ]);
+  }
+
   /// 3. A non-abstract member is inherited from a superclass, and it overrides
   /// an abstract member declared in this class.
   void test_forEachOverridePair_supertypeOverridesThisAbstract() {
     var a = addClass(new Class(
         name: 'A',
         supertype: objectSuper,
         procedures: [newEmptyMethod('foo'), newEmptyMethod('bar')]));
     var b = addClass(new Class(
         name: 'B',
         supertype: a.asThisSupertype,
@@ skipping 999 matching lines @@
     actualText = actualText.replaceAll(' extends core::Object', '');
 
     if (actualText != expectedText) {
       print('-------- Actual --------');
       print(actualText + '------------------------');
     }
 
     expect(actualText, expectedText);
   }
 }