Remove unnecessary Builder classes (#3664)

Author: srawlins

lib/src/element_type.dart

@@ -4,35 +4,22 @@
 
 /// The models used to represent Dart types, all subclasses of [ElementType].
 ///
-/// The only entrypoint for constructing these classes is
-/// [ElementTypeBuilderImpl.typeFrom], which delegates instantiation to various
-/// factories.
+/// The only entrypoint for constructing these classes is [ElementType.for_].
 library;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:dartdoc/src/model/comment_referable.dart';
 import 'package:dartdoc/src/model/model.dart';
-import 'package:dartdoc/src/model/model_object_builder.dart';
 import 'package:dartdoc/src/render/element_type_renderer.dart';
 import 'package:dartdoc/src/runtime_stats.dart';
 import 'package:dartdoc/src/type_utils.dart';
 import 'package:meta/meta.dart';
 
-mixin ElementTypeBuilderImpl implements ElementTypeBuilder {
-  PackageGraph get packageGraph;
-
-  @override
-  ElementType typeFrom(DartType type, Library library) =>
-      ElementType._from(type, library, packageGraph);
-}
-
 /// Base class representing a type in Dartdoc.  It wraps a [DartType], and
 /// may link to a [ModelElement].
-abstract class ElementType
-    with CommentReferable, Nameable, ModelBuilder
-    implements Privacy {
+abstract class ElementType with CommentReferable, Nameable implements Privacy {
   final DartType type;
   @override
   final PackageGraph packageGraph;
@@ -44,7 +31,7 @@ abstract class ElementType
   ElementType._(this.type, this.library, this.packageGraph)
       : nullabilitySuffix = type.nullabilitySuffixWithin(library);
 
-  factory ElementType._from(
+  factory ElementType.for_(
       DartType type, Library library, PackageGraph packageGraph) {
     runtimeStats.incrementAccumulator('elementTypeInstantiation');
     var fElement = type.documentableElement;
@@ -53,7 +40,7 @@ abstract class ElementType
         fElement.kind == ElementKind.NEVER) {
       return UndefinedElementType._from(type, library, packageGraph);
     }
-    var modelElement = packageGraph.modelBuilder.fromElement(fElement);
+    var modelElement = packageGraph.getModelForElement(fElement);
     return DefinedElementType._from(type, modelElement, library, packageGraph);
   }
 
@@ -158,7 +145,7 @@ class FunctionTypeElementType extends UndefinedElementType
       : super._();
 
   List<TypeParameter> get typeFormals => type.typeFormals
-      .map((p) => packageGraph.modelBuilder.from(p, library) as TypeParameter)
+      .map((p) => getModelFor(p, library) as TypeParameter)
       .toList(growable: false);
 
   @override
@@ -220,12 +207,12 @@ class ParameterizedElementType extends DefinedElementType with Rendered {
 
   @override
   late final List<ElementType> typeArguments = type.typeArguments
-      .map((f) => modelBuilder.typeFrom(f, library))
+      .map((f) => getTypeFor(f, library))
       .toList(growable: false);
 }
 
-/// A [ElementType] whose underlying type was referred to by a type alias.
-mixin Aliased implements ElementType, ModelBuilderInterface {
+/// An [ElementType] whose underlying type was referred to by a type alias.
+mixin Aliased implements ElementType {
   Element get typeAliasElement => type.alias!.element;
 
   @override
@@ -235,10 +222,10 @@ mixin Aliased implements ElementType, ModelBuilderInterface {
   bool get isTypedef => true;
 
   late final ModelElement aliasElement =
-      modelBuilder.fromElement(typeAliasElement);
+      ModelElement.forElement(typeAliasElement, packageGraph);
 
   late final List<ElementType> aliasArguments = type.alias!.typeArguments
-      .map((f) => modelBuilder.typeFrom(f, library))
+      .map((f) => getTypeFor(f, library))
       .toList(growable: false);
 }
 
@@ -373,18 +360,17 @@ abstract class DefinedElementType extends ElementType {
   @internal
   @override
   CommentReferable get definingCommentReferable =>
-      modelBuilder.fromElement(modelElement.element);
+      ModelElement.forElement(modelElement.element, packageGraph);
 }
 
 /// Any callable [ElementType] will mix-in this class, whether anonymous or not,
 /// unless it is an alias reference.
 mixin Callable on ElementType {
   List<Parameter> get parameters => type.parameters
-      .map((p) => modelBuilder.from(p, library) as Parameter)
+      .map((p) => getModelFor(p, library) as Parameter)
       .toList(growable: false);
 
-  late final ElementType returnType =
-      modelBuilder.typeFrom(type.returnType, library);
+  late final ElementType returnType = getTypeFor(type.returnType, library);
 
   @override
   // TODO(jcollins-g): mustachio should not require this

lib/src/generator/templates.runtime_renderers.dart

@@ -15,7 +15,6 @@ import 'package:dartdoc/src/model/comment_referable.dart';
 import 'package:dartdoc/src/model/feature_set.dart';
 import 'package:dartdoc/src/model/language_feature.dart';
 import 'package:dartdoc/src/model/model.dart';
-import 'package:dartdoc/src/model/model_object_builder.dart';
 import 'package:dartdoc/src/mustachio/parser.dart';
 import 'package:dartdoc/src/mustachio/renderer_base.dart';
 import 'package:dartdoc/src/warnings.dart';
@@ -426,7 +425,6 @@ class _Renderer_Annotation extends RendererBase<Annotation> {
           CT_,
           () => {
                 ..._Renderer_Attribute.propertyMap<CT_>(),
-                ..._Renderer_ModelBuilder.propertyMap<CT_>(),
                 'annotation': Property(
                   getValue: (CT_ c) => c.annotation,
                   renderVariable: (CT_ c, Property<CT_> self,
@@ -1014,6 +1012,7 @@ class _Renderer_Category extends RendererBase<Category> {
       _propertyMapCache.putIfAbsent(
           CT_,
           () => {
+                ..._Renderer_Object.propertyMap<CT_>(),
                 ..._Renderer_Nameable.propertyMap<CT_>(),
                 ..._Renderer_Warnable.propertyMap<CT_>(),
                 ..._Renderer_CommentReferable.propertyMap<CT_>(),
@@ -1023,7 +1022,6 @@ class _Renderer_Category extends RendererBase<Category> {
                 ..._Renderer_LibraryContainer.propertyMap<CT_>(),
                 ..._Renderer_TopLevelContainer.propertyMap<CT_>(),
                 ..._Renderer_Indexable.propertyMap<CT_>(),
-                ..._Renderer_ModelBuilder.propertyMap<CT_>(),
                 'aboveSidebarPath': Property(
                   getValue: (CT_ c) => c.aboveSidebarPath,
                   renderVariable:
@@ -3874,6 +3872,7 @@ class _Renderer_Documentable extends RendererBase<Documentable> {
       _propertyMapCache.putIfAbsent(
           CT_,
           () => {
+                ..._Renderer_Object.propertyMap<CT_>(),
                 ..._Renderer_Nameable.propertyMap<CT_>(),
                 'aboveSidebarPath': Property(
                   getValue: (CT_ c) => c.aboveSidebarPath,
@@ -4351,7 +4350,6 @@ class _Renderer_ElementType extends RendererBase<ElementType> {
                 ..._Renderer_Object.propertyMap<CT_>(),
                 ..._Renderer_CommentReferable.propertyMap<CT_>(),
                 ..._Renderer_Nameable.propertyMap<CT_>(),
-                ..._Renderer_ModelBuilder.propertyMap<CT_>(),
                 'breadcrumbName': Property(
                   getValue: (CT_ c) => c.breadcrumbName,
                   renderVariable:
@@ -10266,55 +10264,6 @@ class _Renderer_MixinTemplateData extends RendererBase<MixinTemplateData> {
   }
 }
 
-class _Renderer_ModelBuilder extends RendererBase<ModelBuilder> {
-  static final Map<Type, Object> _propertyMapCache = {};
-  static Map<String, Property<CT_>> propertyMap<CT_ extends ModelBuilder>() =>
-      _propertyMapCache.putIfAbsent(
-          CT_,
-          () => {
-                'modelBuilder': Property(
-                  getValue: (CT_ c) => c.modelBuilder,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'ModelObjectBuilder'),
-                  isNullValue: (CT_ c) => false,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    renderSimple(c.modelBuilder, ast, r.template, sink,
-                        parent: r,
-                        getters: _invisibleGetters['ModelObjectBuilder']!);
-                  },
-                ),
-                'packageGraph': Property(
-                  getValue: (CT_ c) => c.packageGraph,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'PackageGraph'),
-                  isNullValue: (CT_ c) => false,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    renderSimple(c.packageGraph, ast, r.template, sink,
-                        parent: r, getters: _invisibleGetters['PackageGraph']!);
-                  },
-                ),
-              }) as Map<String, Property<CT_>>;
-
-  _Renderer_ModelBuilder(ModelBuilder context, RendererBase<Object>? parent,
-      Template template, StringSink sink)
-      : super(context, parent, template, sink);
-
-  @override
-  Property<ModelBuilder>? getProperty(String key) {
-    if (propertyMap<ModelBuilder>().containsKey(key)) {
-      return propertyMap<ModelBuilder>()[key];
-    } else {
-      return null;
-    }
-  }
-}
-
 void _render_ModelElement(ModelElement context, List<MustachioNode> ast,
     Template template, StringSink sink,
     {RendererBase<Object>? parent}) {
@@ -10337,7 +10286,6 @@ class _Renderer_ModelElement extends RendererBase<ModelElement> {
                 ..._Renderer_Indexable.propertyMap<CT_>(),
                 ..._Renderer_FeatureSet.propertyMap<CT_>(),
                 ..._Renderer_DocumentationComment.propertyMap<CT_>(),
-                ..._Renderer_ModelBuilder.propertyMap<CT_>(),
                 'annotations': Property(
                   getValue: (CT_ c) => c.annotations,
                   renderVariable: (CT_ c, Property<CT_> self,
@@ -11531,7 +11479,6 @@ class _Renderer_Nameable extends RendererBase<Nameable> {
       _propertyMapCache.putIfAbsent(
           CT_,
           () => {
-                ..._Renderer_Object.propertyMap<CT_>(),
                 'breadcrumbName': Property(
                   getValue: (CT_ c) => c.breadcrumbName,
                   renderVariable:
@@ -11653,6 +11600,19 @@ class _Renderer_Nameable extends RendererBase<Nameable> {
                         _render_String(e, ast, r.template, sink, parent: r));
                   },
                 ),
+                'packageGraph': Property(
+                  getValue: (CT_ c) => c.packageGraph,
+                  renderVariable: (CT_ c, Property<CT_> self,
+                          List<String> remainingNames) =>
+                      self.renderSimpleVariable(
+                          c, remainingNames, 'PackageGraph'),
+                  isNullValue: (CT_ c) => false,
+                  renderValue: (CT_ c, RendererBase<CT_> r,
+                      List<MustachioNode> ast, StringSink sink) {
+                    renderSimple(c.packageGraph, ast, r.template, sink,
+                        parent: r, getters: _invisibleGetters['PackageGraph']!);
+                  },
+                ),
               }) as Map<String, Property<CT_>>;
 
   _Renderer_Nameable(Nameable context, RendererBase<Object>? parent,
@@ -11870,7 +11830,6 @@ class _Renderer_Package extends RendererBase<Package> {
                 ..._Renderer_Canonicalization.propertyMap<CT_>(),
                 ..._Renderer_Warnable.propertyMap<CT_>(),
                 ..._Renderer_CommentReferable.propertyMap<CT_>(),
-                ..._Renderer_ModelBuilder.propertyMap<CT_>(),
                 'aboveSidebarPath': Property(
                   getValue: (CT_ c) => c.aboveSidebarPath,
                   renderVariable:
@@ -12591,7 +12550,7 @@ class _Renderer_Package extends RendererBase<Package> {
   }
 }
 
-String renderIndex(PackageTemplateData context, Template template) {
+String renderSearchPage(PackageTemplateData context, Template template) {
   var buffer = StringBuffer();
   _render_PackageTemplateData(context, template.ast, template, buffer);
   return buffer.toString();
@@ -12829,7 +12788,7 @@ class _Renderer_PackageTemplateData extends RendererBase<PackageTemplateData> {
   }
 }
 
-String renderSearchPage(PackageTemplateData context, Template template) {
+String renderIndex(PackageTemplateData context, Template template) {
   var buffer = StringBuffer();
   _render_PackageTemplateData(context, template.ast, template, buffer);
   return buffer.toString();
@@ -16883,7 +16842,6 @@ const _invisibleGetters = {
   },
   'ModelElementRenderer': {'hashCode', 'runtimeType'},
   'ModelNode': {'hashCode', 'runtimeType', 'sourceCode'},
-  'ModelObjectBuilder': {'hashCode', 'runtimeType'},
   'PackageGraph': {
     'allConstructedModelElements',
     'allExtensionsAdded',

lib/src/model/accessor.dart

@@ -44,16 +44,16 @@ class Accessor extends ModelElement implements EnclosedElement {
   ExecutableMember? get originalMember =>
       super.originalMember as ExecutableMember?;
 
-  late final Callable modelType = modelBuilder.typeFrom(
-      (originalMember ?? element).type, library) as Callable;
+  late final Callable modelType =
+      getTypeFor((originalMember ?? element).type, library) as Callable;
 
   bool get isSynthetic => element.isSynthetic;
 
   SourceCodeRenderer get _sourceCodeRenderer => const SourceCodeRendererHtml();
 
   // The [enclosingCombo] where this element was defined.
   late final GetterSetterCombo definingCombo =
-      modelBuilder.fromElement(element.variable) as GetterSetterCombo;
+      getModelForElement(element.variable) as GetterSetterCombo;
 
   String get _sourceCode {
     if (!isSynthetic) {
@@ -123,11 +123,10 @@ class Accessor extends ModelElement implements EnclosedElement {
   @override
   ModelElement get enclosingElement {
     if (element.enclosingElement is CompilationUnitElement) {
-      return modelBuilder
-          .fromElement(element.enclosingElement.enclosingElement!);
+      return getModelForElement(element.enclosingElement.enclosingElement!);
     }
 
-    return modelBuilder.from(element.enclosingElement, library);
+    return packageGraph.getModelFor(element.enclosingElement, library);
   }
 
   @override
@@ -236,7 +235,7 @@ class ContainerAccessor extends Accessor with ContainerMember, Inheritable {
         continue;
       }
       final parentContainer =
-          modelBuilder.fromElement(supertype.element) as InheritingContainer;
+          getModelForElement(supertype.element) as InheritingContainer;
       final possibleFields =
           parentContainer.declaredFields.where((f) => !f.isStatic);
       final fieldName = accessor.name.replaceFirst('=', '');

lib/src/model/annotation.dart

@@ -10,16 +10,14 @@ import 'package:dartdoc/src/model/attribute.dart';
 import 'package:dartdoc/src/model/class.dart';
 import 'package:dartdoc/src/model/getter_setter_combo.dart';
 import 'package:dartdoc/src/model/library.dart';
-import 'package:dartdoc/src/model/model_object_builder.dart';
 import 'package:dartdoc/src/model/package_graph.dart';
 
 /// Represents a Dart annotation, attached to an element in the source code with
 /// `@`.
-class Annotation extends Attribute with ModelBuilder {
+class Annotation extends Attribute {
   final ElementAnnotation annotation;
   final Library library;
 
-  @override
   final PackageGraph packageGraph;
 
   Annotation(this.annotation, this.library, this.packageGraph)
@@ -31,15 +29,16 @@ class Annotation extends Attribute with ModelBuilder {
 
   @override
   String get linkedName => annotation.element is PropertyAccessorElement
-      ? modelBuilder.fromElement(annotation.element!).linkedName
+      ? packageGraph.getModelForElement(annotation.element!).linkedName
       // TODO(jcollins-g): consider linking to constructor instead of type?
       : modelType.linkedName;
 
   late final ElementType modelType = switch (annotation.element) {
     ConstructorElement(:var returnType) =>
-      modelBuilder.typeFrom(returnType, library),
+      packageGraph.getTypeFor(returnType, library),
     PropertyAccessorElement(:var variable) =>
-      (modelBuilder.fromElement(variable) as GetterSetterCombo).modelType,
+      (packageGraph.getModelForElement(variable) as GetterSetterCombo)
+          .modelType,
     _ => throw StateError(
         'non-callable element used as annotation?: ${annotation.element}')
   };

lib/src/model/category.dart

@@ -7,21 +7,20 @@ import 'package:analyzer/file_system/file_system.dart';
 import 'package:dartdoc/src/dartdoc_options.dart';
 import 'package:dartdoc/src/model/comment_referable.dart';
 import 'package:dartdoc/src/model/model.dart';
-import 'package:dartdoc/src/model/model_object_builder.dart';
 import 'package:dartdoc/src/warnings.dart';
 
 /// A subcategory of a package, containing elements tagged with `{@category}`.
-class Category extends Nameable
+class Category
     with
+        Nameable,
         Warnable,
         CommentReferable,
         Locatable,
         Canonicalization,
         MarkdownFileDocumentation,
         LibraryContainer,
         TopLevelContainer,
-        Indexable,
-        ModelBuilder
+        Indexable
     implements Documentable {
   /// All libraries in [libraries] must come from [_package].
   @override