Display indirectly implemented types via extended and mixed-in types

Author: srawlins

lib/src/model/inheriting_container.dart

@@ -453,13 +453,13 @@ abstract class InheritingContainer extends Container {
       }
     }
 
-    for (var interface in directInterfaces) {
-      var interfaceElement = interface.modelElement;
+    void addFromSupertype(DefinedElementType supertype) {
+      var interfaceElement = supertype.modelElement;
 
       /// Do not recurse if we can find an element here.
       if (interfaceElement.canonicalModelElement != null) {
-        addInterfaceIfUnique(interface);
-        continue;
+        addInterfaceIfUnique(supertype);
+        return;
       }
       // Public types used to be unconditionally exposed here.  However,
       // if the packages are [DocumentLocation.missing] we generally treat types
@@ -474,18 +474,30 @@ abstract class InheritingContainer extends Container {
       if (interfaceElement is! InheritingContainer) {
         assert(
           false,
-          'Can not handle intermediate non-public interfaces created by '
+          'Cannot handle intermediate non-public interfaces created by '
           "ModelElements that are not classes or mixins: '$fullyQualifiedName' "
-          "contains an interface '$interface', defined by '$interfaceElement'",
+          "contains a supertype '$supertype', defined by '$interfaceElement'",
         );
-        continue;
+        return;
       }
       var publicSuperChain = interfaceElement.superChain.wherePublic;
       if (publicSuperChain.isNotEmpty) {
         addInterfaceIfUnique(publicSuperChain.first);
       }
       interfaceElement.publicInterfaces.forEach(addInterfaceIfUnique);
     }
+
+    for (var interface in directInterfaces) {
+      addFromSupertype(interface);
+    }
+    for (var supertype in superChain) {
+      addFromSupertype(supertype);
+    }
+    if (this case Class(:var mixedInTypes) || Enum(:var mixedInTypes)) {
+      for (var mixin in mixedInTypes) {
+        addFromSupertype(mixin);
+      }
+    }
     return interfaces;
   }
 

test/classes_test.dart

@@ -109,6 +109,56 @@ class C implements _B {}
     expect(c.publicInterfaces.first.modelElement, library.classes.named('A'));
   }
 
+  void test_publicInterfaces_indirectViaPrivate2() async {
+    var library = await bootPackageWithLibrary('''
+class A {}
+class _B implements A {}
+class _C implements _B {}
+class D implements _C {}
+''');
+
+    var c = library.classes.named('D');
+    expect(c.publicInterfaces, hasLength(1));
+    expect(c.publicInterfaces.first.modelElement, library.classes.named('A'));
+  }
+
+  void test_publicInterfaces_indirectViaPrivateExtendedClass() async {
+    var library = await bootPackageWithLibrary('''
+class A {}
+class _B implements A {}
+class C extends _B {}
+''');
+
+    var c = library.classes.named('C');
+    expect(c.publicInterfaces, hasLength(1));
+    expect(c.publicInterfaces.first.modelElement, library.classes.named('A'));
+  }
+
+  void test_publicInterfaces_indirectViaPrivateExtendedClass2() async {
+    var library = await bootPackageWithLibrary('''
+class A {}
+class _B implements A {}
+class _C extends _B {}
+class D extends _C {}
+''');
+
+    var c = library.classes.named('D');
+    expect(c.publicInterfaces, hasLength(1));
+    expect(c.publicInterfaces.first.modelElement, library.classes.named('A'));
+  }
+
+  void test_publicInterfaces_indirectViaPrivateMixedInMixin() async {
+    var library = await bootPackageWithLibrary('''
+class A {}
+mixin _M implements A {}
+class C with _M {}
+''');
+
+    var c = library.classes.named('C');
+    expect(c.publicInterfaces, hasLength(1));
+    expect(c.publicInterfaces.first.modelElement, library.classes.named('A'));
+  }
+
   void test_publicInterfaces_indirectViaPrivate_multiply() async {
     var library = await bootPackageWithLibrary('''
 class A<T> {}