Correctly handle intermediate abstract classes containing (external?) implementations (#2449)

* Add test

* It's Object that is the problem...

* update test

* adjustment

* Fix up test

* Cleanups

Author: jcollins-g

lib/src/model/class.dart

@@ -376,12 +376,39 @@ class Class extends Container
       var cmap = inheritance.getInheritedConcreteMap2(element);
       var imap = inheritance.getInheritedMap2(element);
 
+      var inheritanceChainElements;
+
       var combinedMap = <String, ExecutableElement>{};
       for (var nameObj in cmap.keys) {
         combinedMap[nameObj.name] = cmap[nameObj];
       }
       for (var nameObj in imap.keys) {
-        combinedMap[nameObj.name] ??= imap[nameObj];
+        if (combinedMap[nameObj.name] != null) {
+          // Elements in the inheritance chain starting from [this.element]
+          // down to, but not including, [Object].
+          inheritanceChainElements ??=
+              inheritanceChain.map((c) => c.element).toList();
+          // [packageGraph.specialClasses] is not available yet.
+          bool _isDartCoreObject(ClassElement e) =>
+              e.name == 'Object' && e.library.name == 'dart.core';
+          assert(inheritanceChainElements
+                  .contains(imap[nameObj].enclosingElement) ||
+              _isDartCoreObject(imap[nameObj].enclosingElement));
+
+          // If the concrete object from [InheritanceManager3.getInheritedConcreteMap2]
+          // is farther from this class in the inheritance chain than the one
+          // provided by InheritedMap2, prefer InheritedMap2.  This
+          // correctly accounts for intermediate abstract classes that have
+          // method/field implementations.
+          if (inheritanceChainElements
+                  .indexOf(combinedMap[nameObj.name].enclosingElement) <
+              inheritanceChainElements
+                  .indexOf(imap[nameObj].enclosingElement)) {
+            combinedMap[nameObj.name] = imap[nameObj];
+          }
+        } else {
+          combinedMap[nameObj.name] = imap[nameObj];
+        }
       }
 
       __inheritedElements = combinedMap.values.toList();

test/end2end/model_test.dart

@@ -1313,6 +1313,27 @@ void main() {
   });
 
   group('Class edge cases', () {
+    test('Overrides from intermediate abstract classes are picked up correctly',
+        () {
+      var IntermediateAbstractSubclass = fakeLibrary.allClasses
+          .firstWhere((c) => c.name == 'IntermediateAbstractSubclass');
+      var operatorEquals = IntermediateAbstractSubclass.inheritedOperators
+          .firstWhere((o) => o.name == 'operator ==');
+      expect(operatorEquals.definingEnclosingContainer.name,
+          equals('IntermediateAbstract'));
+    });
+
+    test(
+        'Overrides from intermediate abstract classes that have external implementations via the SDK are picked up correctly',
+        () {
+      var dartCore =
+          packageGraph.libraries.firstWhere((l) => l.name == 'dart:core');
+      var intClass = dartCore.allClasses.firstWhere((c) => c.name == 'int');
+      var operatorEqualsInt = intClass.inheritedOperators
+          .firstWhere((o) => o.name == 'operator ==');
+      expect(operatorEqualsInt.definingEnclosingContainer.name, equals('num'));
+    });
+
     test('Factories from unrelated classes are linked correctly', () {
       var A = packageGraph.localPublicLibraries
           .firstWhere((l) => l.name == 'unrelated_factories')

testing/test_package/lib/fake.dart

@@ -1228,3 +1228,13 @@ class Super4 implements Super1 {}
 class _Super5 implements _Super2 {}
 
 class Super6 implements _Super5 {}
+
+
+abstract class IntermediateAbstract implements Object {
+  /// This is an override.
+  @override
+  bool operator==(Object other) {}
+}
+
+/// This should inherit [==] from [IntermediateAbstract].
+class IntermediateAbstractSubclass extends IntermediateAbstract {}