Simplify how inheritance is computed. (#4079)

The motivation here is that
`Inheritable.computeCanonicalEnclosingContainer` is a complicated
subroutine,

[even](12d271a)
[after](d629e1e)
[several](dcc239a)
[refactorings](95f4208).
This is the code that decides where to link inherited members. So
questions like "ah ha, `List` has a `.isEmpty`, but it inherits the docs
from... `Iterable.isEmpty`." It's the wild west out there, with docs
coming from indirect supertypes, interfaces, mixins, etc.

A big portion of the complexity comes from choosing an order in which to
search the supertypes. We have to take a directed acyclic graph, and
choose an order. Prior to this change, the ordering comes from each
container class's implementation of `get inheritanceChain`. I think on
paper this sounds like a good idea: let a Mixin compute its inheritance
chain, let an Enum compute its inheritance chain. In practice, it spread
complexity out too much, and a combined implementation is actually quite
compact.

So in this change we remove `InheritingContainer.inheritanceChain`, the
`expandInheritanceChain` extension getter, and
`Inheritable._inheritance`. We replace all of this code with
`Inheritable._enclosingSuperTypes`, which returns all of the various
supertypes of the enclosing element, in a specific order. This getter
performs a fairly simple walk up the inheritance tree (extended types,
implemented types, mixed-in types, and superclass constraints).

The single call to `Inheritable._inheritance` is now a call to
`Inheritable._enclosingSuperTypes`. `computeCanonicalEnclosingContainer`
calls this in order to collect its set of candidates for the canonical
enclosing container. `_enclosingSuperTypes` handles `Object`
differently, which allows the impl of
`computeCanonicalEnclosingContainer` to be much simplified, no longer
concerning itself with any _previous_ candidate.

This is very nearly a no-op. There is some change in the handling of
`Object` and it's members. Because of this, we tweak the `enum_test` to
no longer use `--no-link-to-remote`, so that the links to
Object.hashCode and Enum.index continue to work.

I tested this with some manual verification of the Dart SDK docs,
Flutter SDK docs, and the collection package docs.

Author: srawlins

lib/src/generator/templates.runtime_renderers.dart

@@ -2734,34 +2734,6 @@ class _Renderer_Class extends RendererBase<Class> {
                       );
                     },
               ),
-              'inheritanceChain': Property(
-                getValue: (CT_ c) => c.inheritanceChain,
-                renderVariable:
-                    (CT_ c, Property<CT_> self, List<String> remainingNames) =>
-                        self.renderSimpleVariable(
-                          c,
-                          remainingNames,
-                          'List<InheritingContainer>',
-                        ),
-
-                renderIterable:
-                    (
-                      CT_ c,
-                      RendererBase<CT_> r,
-                      List<MustachioNode> ast,
-                      StringSink sink,
-                    ) {
-                      return c.inheritanceChain.map(
-                        (e) => _render_InheritingContainer(
-                          e,
-                          ast,
-                          r.template,
-                          sink,
-                          parent: r,
-                        ),
-                      );
-                    },
-              ),
               'isAbstract': Property(
                 getValue: (CT_ c) => c.isAbstract,
                 renderVariable:
@@ -7213,34 +7185,6 @@ class _Renderer_Enum extends RendererBase<Enum> {
                       );
                     },
               ),
-              'inheritanceChain': Property(
-                getValue: (CT_ c) => c.inheritanceChain,
-                renderVariable:
-                    (CT_ c, Property<CT_> self, List<String> remainingNames) =>
-                        self.renderSimpleVariable(
-                          c,
-                          remainingNames,
-                          'List<InheritingContainer>',
-                        ),
-
-                renderIterable:
-                    (
-                      CT_ c,
-                      RendererBase<CT_> r,
-                      List<MustachioNode> ast,
-                      StringSink sink,
-                    ) {
-                      return c.inheritanceChain.map(
-                        (e) => _render_InheritingContainer(
-                          e,
-                          ast,
-                          r.template,
-                          sink,
-                          parent: r,
-                        ),
-                      );
-                    },
-              ),
               'isAbstract': Property(
                 getValue: (CT_ c) => c.isAbstract,
                 renderVariable:
@@ -8519,34 +8463,6 @@ class _Renderer_ExtensionType extends RendererBase<ExtensionType> {
                       );
                     },
               ),
-              'inheritanceChain': Property(
-                getValue: (CT_ c) => c.inheritanceChain,
-                renderVariable:
-                    (CT_ c, Property<CT_> self, List<String> remainingNames) =>
-                        self.renderSimpleVariable(
-                          c,
-                          remainingNames,
-                          'List<InheritingContainer>',
-                        ),
-
-                renderIterable:
-                    (
-                      CT_ c,
-                      RendererBase<CT_> r,
-                      List<MustachioNode> ast,
-                      StringSink sink,
-                    ) {
-                      return c.inheritanceChain.map(
-                        (e) => _render_InheritingContainer(
-                          e,
-                          ast,
-                          r.template,
-                          sink,
-                          parent: r,
-                        ),
-                      );
-                    },
-              ),
               'isAbstract': Property(
                 getValue: (CT_ c) => c.isAbstract,
                 renderVariable:
@@ -11894,34 +11810,6 @@ class _Renderer_InheritingContainer extends RendererBase<InheritingContainer> {
 
                 getBool: (CT_ c) => c.hasPublicSuperChainReversed,
               ),
-              'inheritanceChain': Property(
-                getValue: (CT_ c) => c.inheritanceChain,
-                renderVariable:
-                    (CT_ c, Property<CT_> self, List<String> remainingNames) =>
-                        self.renderSimpleVariable(
-                          c,
-                          remainingNames,
-                          'List<InheritingContainer>',
-                        ),
-
-                renderIterable:
-                    (
-                      CT_ c,
-                      RendererBase<CT_> r,
-                      List<MustachioNode> ast,
-                      StringSink sink,
-                    ) {
-                      return c.inheritanceChain.map(
-                        (e) => _render_InheritingContainer(
-                          e,
-                          ast,
-                          r.template,
-                          sink,
-                          parent: r,
-                        ),
-                      );
-                    },
-              ),
               'instanceFields': Property(
                 getValue: (CT_ c) => c.instanceFields,
                 renderVariable:
@@ -15922,34 +15810,6 @@ class _Renderer_Mixin extends RendererBase<Mixin> {
 
                 getBool: (CT_ c) => c.hasPublicSuperclassConstraints,
               ),
-              'inheritanceChain': Property(
-                getValue: (CT_ c) => c.inheritanceChain,
-                renderVariable:
-                    (CT_ c, Property<CT_> self, List<String> remainingNames) =>
-                        self.renderSimpleVariable(
-                          c,
-                          remainingNames,
-                          'List<InheritingContainer>',
-                        ),
-
-                renderIterable:
-                    (
-                      CT_ c,
-                      RendererBase<CT_> r,
-                      List<MustachioNode> ast,
-                      StringSink sink,
-                    ) {
-                      return c.inheritanceChain.map(
-                        (e) => _render_InheritingContainer(
-                          e,
-                          ast,
-                          r.template,
-                          sink,
-                          parent: r,
-                        ),
-                      );
-                    },
-              ),
               'isAbstract': Property(
                 getValue: (CT_ c) => c.isAbstract,
                 renderVariable:
@@ -25741,6 +25601,7 @@ const _invisibleGetters = {
     'nonSynthetic2',
     'runtimeType',
     'session',
+    'sinceSdkVersion',
   },
   'EnumElement2': {
     'constants2',
@@ -26192,6 +26053,7 @@ const _invisibleGetters = {
     'baseElement',
     'children',
     'children2',
+    'constantInitializer',
     'constantInitializer2',
     'context',
     'declaration',

lib/src/model/class.dart

@@ -14,8 +14,6 @@ import 'package:dartdoc/src/model/model.dart';
 /// **instance**: As with [Container], but also includes inherited children.
 /// **inherited**: Filtered getters giving only inherited children.
 class Class extends InheritingContainer with Constructable, MixedInTypes {
-  @override
-
   @override
   final ClassElement2 element;
 
@@ -29,22 +27,6 @@ class Class extends InheritingContainer with Constructable, MixedInTypes {
   String get sidebarPath =>
       '${canonicalLibraryOrThrow.dirName}/$name-class-sidebar.html';
 
-  @override
-  late final List<InheritingContainer> inheritanceChain = [
-    this,
-
-    // Caching should make this recursion a little less painful.
-    for (var container in mixedInTypes.modelElements.reversed)
-      ...container.inheritanceChain,
-
-    for (var container in superChain.modelElements)
-      ...container.inheritanceChain,
-
-    // Interfaces need to come last, because classes in the superChain might
-    // implement them even when they aren't mentioned.
-    ...interfaceElements.expandInheritanceChain,
-  ];
-
   Class(this.element, Library library, PackageGraph packageGraph)
       : super(library, packageGraph) {
     if (element.name3 == 'Object' &&
@@ -75,8 +57,7 @@ class Class extends InheritingContainer with Constructable, MixedInTypes {
   bool get isFinal => element.isFinal && !element.isSealed;
 
   @override
-  bool get isImplementableInterface =>
-      element.isInterface && !element.isSealed;
+  bool get isImplementableInterface => element.isInterface && !element.isSealed;
 
   @override
   bool get isMixinClass => element.isMixinClass;

lib/src/model/enum.dart

@@ -20,16 +20,6 @@ class Enum extends InheritingContainer with Constructable, MixedInTypes {
     ...constructors,
   ];
 
-  @override
-  late final List<InheritingContainer> inheritanceChain = [
-    this,
-    for (var container in mixedInTypes.modelElements.reversed)
-      ...container.inheritanceChain,
-    for (var container in superChain.modelElements)
-      ...container.inheritanceChain,
-    ...interfaceElements.expandInheritanceChain,
-  ];
-
   @override
   // Prevent a collision with the library file.
   String get fileName => name == 'index' ? '$name-enum.html' : '$name.html';

lib/src/model/extension_type.dart

@@ -10,9 +10,8 @@ import 'package:dartdoc/src/model/model.dart';
 import 'package:meta/meta.dart';
 
 class ExtensionType extends InheritingContainer with Constructable {
-
   @override
-  final ExtensionTypeElement2  element;
+  final ExtensionTypeElement2 element;
 
   late final ElementType representationType =
       getTypeFor(element.representation2.type, library);
@@ -45,13 +44,11 @@ class ExtensionType extends InheritingContainer with Constructable {
     ContainerAccessor? getter, setter;
     final fieldGetter = field.getter2;
     if (fieldGetter != null) {
-      getter = ContainerAccessor(
-          fieldGetter, library, packageGraph, this);
+      getter = ContainerAccessor(fieldGetter, library, packageGraph, this);
     }
     final fieldSetter = field.setter2;
     if (fieldSetter != null) {
-      setter = ContainerAccessor(
-          fieldSetter, library, packageGraph, this);
+      setter = ContainerAccessor(fieldSetter, library, packageGraph, this);
     }
     return getModelForPropertyInducingElement(field, library,
         getter: getter, setter: setter) as Field;
@@ -63,12 +60,6 @@ class ExtensionType extends InheritingContainer with Constructable {
     ...constructors,
   ];
 
-  @override
-  late final List<InheritingContainer> inheritanceChain = [
-    this,
-    ...interfaceElements.expandInheritanceChain,
-  ];
-
   @override
   String get fileName => '$name-extension-type.html';