exposing mixin types seems bad

Author: jcollins-g

lib/src/generator/templates.dart

@@ -50,7 +50,6 @@ const _visibleTypes = {
   Category,
   Class,
   Constructor,
-  Constructable,
   DefinedElementType,
   Documentable,
   ElementType,
@@ -63,13 +62,11 @@ const _visibleTypes = {
   Library,
   LibraryContainer,
   Method,
-  MixedInTypes,
   ModelElement,
   Package,
   // For getters like `isNotEmpty`; perhaps a smell, but currently in use.
   String,
   TopLevelVariable,
-  TypeInterfaces,
   TypeParameter,
 };
 

lib/src/generator/templates.runtime_renderers.dart

@@ -14009,13 +14009,6 @@ class _Renderer_TopLevelVariable extends RendererBase<TopLevelVariable> {
   }
 }
 
-void _render_TypeInterfaces(TypeInterfaces context, List<MustachioNode> ast,
-    Template template, StringSink sink,
-    {RendererBase<Object> parent}) {
-  var renderer = _Renderer_TypeInterfaces(context, parent, template, sink);
-  renderer.renderBlock(ast);
-}
-
 class _Renderer_TypeInterfaces extends RendererBase<TypeInterfaces> {
   static final Map<Type, Object> _propertyMapCache = {};
   static Map<String, Property<CT_>> propertyMap<CT_ extends TypeInterfaces>() =>
@@ -14074,11 +14067,11 @@ class _Renderer_TypeInterfaces extends RendererBase<TypeInterfaces> {
                   renderVariable: (CT_ c, Property<CT_> self,
                           List<String> remainingNames) =>
                       self.renderSimpleVariable(
-                          c, remainingNames, 'Iterable<TypeInterfaces>'),
+                          c, remainingNames, 'Iterable<InheritingContainer>'),
                   renderIterable: (CT_ c, RendererBase<CT_> r,
                       List<MustachioNode> ast, StringSink sink) {
                     return c.publicImplementors.map((e) =>
-                        _render_TypeInterfaces(e, ast, r.template, sink,
+                        _render_InheritingContainer(e, ast, r.template, sink,
                             parent: r));
                   },
                 ),
@@ -14087,11 +14080,11 @@ class _Renderer_TypeInterfaces extends RendererBase<TypeInterfaces> {
                   renderVariable: (CT_ c, Property<CT_> self,
                           List<String> remainingNames) =>
                       self.renderSimpleVariable(
-                          c, remainingNames, 'Iterable<TypeInterfaces>'),
+                          c, remainingNames, 'Iterable<InheritingContainer>'),
                   renderIterable: (CT_ c, RendererBase<CT_> r,
                       List<MustachioNode> ast, StringSink sink) {
                     return c.publicImplementorsSorted.map((e) =>
-                        _render_TypeInterfaces(e, ast, r.template, sink,
+                        _render_InheritingContainer(e, ast, r.template, sink,
                             parent: r));
                   },
                 ),

lib/src/model/inheriting_container.dart

@@ -177,13 +177,13 @@ mixin TypeInterfaces on InheritingContainer {
   ///
   /// If this [InheritingContainer] has a private implementor, then that is
   /// counted as a proxy for any public implementors of that private container.
-  Iterable<TypeInterfaces> get publicImplementors {
-    var result = <TypeInterfaces>{};
-    var seen = <TypeInterfaces>{};
+  Iterable<InheritingContainer> get publicImplementors {
+    var result = <InheritingContainer>{};
+    var seen = <InheritingContainer>{};
 
     // Recursively adds [implementor] if public, or the implementors of
     // [implementor] if not.
-    void addToResult(TypeInterfaces implementor) {
+    void addToResult(InheritingContainer implementor) {
       if (seen.contains(implementor)) return;
       seen.add(implementor);
       if (implementor.isPublicAndPackageDocumented) {
@@ -201,9 +201,9 @@ mixin TypeInterfaces on InheritingContainer {
     return result;
   }
 
-  List<TypeInterfaces> _publicImplementorsSorted;
+  List<InheritingContainer> _publicImplementorsSorted;
 
-  Iterable<TypeInterfaces> get publicImplementorsSorted =>
+  Iterable<InheritingContainer> get publicImplementorsSorted =>
       _publicImplementorsSorted ??= publicImplementors.toList()..sort(byName);
 }
 

lib/src/model/package_graph.dart

@@ -182,7 +182,7 @@ class PackageGraph with CommentReferable, Nameable {
   /// is true.
   bool allExtensionsAdded = false;
 
-  Map<TypeInterfaces, List<TypeInterfaces>> get implementors {
+  Map<InheritingContainer, List<InheritingContainer>> get implementors {
     assert(allImplementorsAdded);
     return _implementors;
   }
@@ -220,10 +220,12 @@ class PackageGraph with CommentReferable, Nameable {
       HashMap<Tuple2<Element, Library>, Set<ModelElement>>();
 
   /// A mapping of the list of classes which implement each class.
-  final _implementors = LinkedHashMap<TypeInterfaces, List<TypeInterfaces>>(
-      equals: (TypeInterfaces a, TypeInterfaces b) =>
-          a.definingContainer == b.definingContainer,
-      hashCode: (TypeInterfaces clazz) => clazz.definingContainer.hashCode);
+  final _implementors =
+      LinkedHashMap<InheritingContainer, List<InheritingContainer>>(
+          equals: (InheritingContainer a, InheritingContainer b) =>
+              a.definingContainer == b.definingContainer,
+          hashCode: (InheritingContainer clazz) =>
+              clazz.definingContainer.hashCode);
 
   /// A list of extensions that exist in the package graph.
   final List<Extension> _extensions = [];

lib/src/model_utils.dart

@@ -93,10 +93,11 @@ Iterable<T> filterNonPublic<T extends Privacy>(Iterable<T> privacyItems) {
 
 /// Finds canonical classes for all classes in the iterable, if possible.
 /// If a canonical class can not be found, returns the original class.
-Iterable<TypeInterfaces> findCanonicalFor(Iterable<TypeInterfaces> containers) {
+Iterable<InheritingContainer> findCanonicalFor(
+    Iterable<InheritingContainer> containers) {
   return containers.map((c) =>
       c.packageGraph.findCanonicalModelElementFor(c.element)
-          as TypeInterfaces ??
+          as InheritingContainer ??
       c);
 }