Modify summary codegen so that builder getters return builders.

pkg/analyzer/lib/src/summary/format.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'base.dart' as base;
@@ skipping 420 matching lines @@
 class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements LinkedLibrary {
   bool _finished = false;
 
   List<LinkedUnitBuilder> _units;
   List<LinkedDependencyBuilder> _dependencies;
   List<int> _importDependencies;
   List<LinkedExportNameBuilder> _exportNames;
   int _numPrelinkedDependencies;
 
   @override
-  List<LinkedUnit> get units => _units ?? const <LinkedUnit>[];
+  List<LinkedUnitBuilder> get units => _units ?? const <LinkedUnit>[];

[scheglov, 2016/01/20 17:13:06]

Should we also replace type arguments of the default lists?

[Paul Berry, 2016/01/20 17:31:01]

Hmm, good question.  Since this is a const list, it probably doesn't matter for
now.

But maybe it would be even better for this line to read:

    List<LinkedUnitBuilder> get units => _units ??= <LinkedUnitBuilder>[];

This would have the advantage of allowing code like the following:

    LinkedLibraryBuilder llb = new LinkedLibraryBuilder();
    llb.units.add(new LinkedUnitBuilder(...));

I'll do some experiments and get back to you.

 
   /**
    * The linked summary of all the compilation units constituting the
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
    * declarations in the defining compilation unit.
    */
   void set units(List<LinkedUnitBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
   @override
-  List<LinkedDependency> get dependencies => _dependencies ?? const <LinkedDependency>[];
+  List<LinkedDependencyBuilder> get dependencies => _dependencies ?? const <LinkedDependency>[];
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
    * representing the library itself (it is also used for "dynamic").  This is
    * followed by elements representing "prelinked" dependencies (direct imports
    * and the transitive closure of exports).  After the prelinked dependencies
    * are elements represent "linked" dependencies.
    *
@@ skipping 14 matching lines @@
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     _importDependencies = _value;
   }
 
   @override
-  List<LinkedExportName> get exportNames => _exportNames ?? const <LinkedExportName>[];
+  List<LinkedExportNameBuilder> get exportNames => _exportNames ?? const <LinkedExportName>[];
 
   /**
    * Information about entities in the export namespace of the library that are
    * not in the public namespace of the library (that is, entities that are
    * brought into the namespace via `export` directives).
    *
    * Sorted by name.
    */
   void set exportNames(List<LinkedExportNameBuilder> _value) {
     assert(!_finished);
@@ skipping 386 matching lines @@
   };
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
   List<TypeRefBuilder> _types;
 
   @override
-  List<LinkedReference> get references => _references ?? const <LinkedReference>[];
+  List<LinkedReferenceBuilder> get references => _references ?? const <LinkedReference>[];
 
   /**
    * Information about the resolution of references within the compilation
    * unit.  Each element of [UnlinkedUnit.references] has a corresponding
    * element in this list (at the same index).  If this list has additional
    * elements beyond the number of elements in [UnlinkedUnit.references], those
    * additional elements are references that are only referred to implicitly
    * (e.g. elements involved in inferred or propagated types).
    */
   void set references(List<LinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
   @override
-  List<TypeRef> get types => _types ?? const <TypeRef>[];
+  List<TypeRefBuilder> get types => _types ?? const <TypeRef>[];
 
   /**
    * List associating slot ids found inside the unlinked summary for the
    * compilation unit with propagated and inferred types.
    */
   void set types(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _types = _value;
   }
 
@@ skipping 94 matching lines @@
 
   /**
    * The list of URIs of items in [linkedLibraries], e.g. `dart:core`.
    */
   void set linkedLibraryUris(List<String> _value) {
     assert(!_finished);
     _linkedLibraryUris = _value;
   }
 
   @override
-  List<LinkedLibrary> get linkedLibraries => _linkedLibraries ?? const <LinkedLibrary>[];
+  List<LinkedLibraryBuilder> get linkedLibraries => _linkedLibraries ?? const <LinkedLibrary>[];
 
   /**
    * Linked libraries.
    */
   void set linkedLibraries(List<LinkedLibraryBuilder> _value) {
     assert(!_finished);
     _linkedLibraries = _value;
   }
 
   @override
   List<String> get unlinkedUnitUris => _unlinkedUnitUris ?? const <String>[];
 
   /**
    * The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
    */
   void set unlinkedUnitUris(List<String> _value) {
     assert(!_finished);
     _unlinkedUnitUris = _value;
   }
 
   @override
-  List<UnlinkedUnit> get unlinkedUnits => _unlinkedUnits ?? const <UnlinkedUnit>[];
+  List<UnlinkedUnitBuilder> get unlinkedUnits => _unlinkedUnits ?? const <UnlinkedUnit>[];
 
   /**
    * Unlinked information for the compilation units constituting the SDK.
    */
   void set unlinkedUnits(List<UnlinkedUnitBuilder> _value) {
     assert(!_finished);
     _unlinkedUnits = _value;
   }
 
   SdkBundleBuilder({List<String> linkedLibraryUris, List<LinkedLibraryBuilder> linkedLibraries, List<String> unlinkedUnitUris, List<UnlinkedUnitBuilder> unlinkedUnits})
@@ skipping 187 matching lines @@
    *
    * If the type being referred to is not a type parameter, [paramReference] is
    * zero.
    */
   void set paramReference(int _value) {
     assert(!_finished);
     _paramReference = _value;
   }
 
   @override
-  List<TypeRef> get typeArguments => _typeArguments ?? const <TypeRef>[];
+  List<TypeRefBuilder> get typeArguments => _typeArguments ?? const <TypeRef>[];
 
   /**
    * If this is an instantiation of a generic type, the type arguments used to
    * instantiate it.  Trailing type arguments of type `dynamic` are omitted.
    */
   void set typeArguments(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _typeArguments = _value;
   }
 
@@ skipping 165 matching lines @@
 
   /**
    * Offset of the class name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the class, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRef get supertype => _supertype;
+  TypeRefBuilder get supertype => _supertype;
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
   void set supertype(TypeRefBuilder _value) {
     assert(!_finished);
     _supertype = _value;
   }
 
   @override
-  List<TypeRef> get mixins => _mixins ?? const <TypeRef>[];
+  List<TypeRefBuilder> get mixins => _mixins ?? const <TypeRef>[];
 
   /**
    * Mixins appearing in a `with` clause, if any.
    */
   void set mixins(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _mixins = _value;
   }
 
   @override
-  List<TypeRef> get interfaces => _interfaces ?? const <TypeRef>[];
+  List<TypeRefBuilder> get interfaces => _interfaces ?? const <TypeRef>[];
 
   /**
    * Interfaces appearing in an `implements` clause, if any.
    */
   void set interfaces(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _interfaces = _value;
   }
 
   @override
-  List<UnlinkedVariable> get fields => _fields ?? const <UnlinkedVariable>[];
+  List<UnlinkedVariableBuilder> get fields => _fields ?? const <UnlinkedVariable>[];
 
   /**
    * Field declarations contained in the class.
    */
   void set fields(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _fields = _value;
   }
 
   @override
-  List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
+  List<UnlinkedExecutableBuilder> get executables => _executables ?? const <UnlinkedExecutable>[];
 
   /**
    * Executable objects (methods, getters, and setters) contained in the class.
    */
   void set executables(List<UnlinkedExecutableBuilder> _value) {
     assert(!_finished);
     _executables = _value;
   }
 
   @override
@@ skipping 464 matching lines @@
   /**
    * Sequence of strings consumed by the operations `pushString` and
    * `invokeConstructor`.
    */
   void set strings(List<String> _value) {
     assert(!_finished);
     _strings = _value;
   }
 
   @override
-  List<TypeRef> get references => _references ?? const <TypeRef>[];
+  List<TypeRefBuilder> get references => _references ?? const <TypeRef>[];
 
   /**
    * Sequence of language constructs consumed by the operations
    * `pushReference`, `invokeConstructor`, `makeList`, and `makeMap`.  Note
    * that in the case of `pushReference` (and sometimes `invokeConstructor` the
    * actual entity being referred to may be something other than a type.
    */
   void set references(List<TypeRefBuilder> _value) {
     assert(!_finished);
     _references = _value;
@@ skipping 317 matching lines @@
 
   /**
    * Offset of the enum name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the enum, or `null` if there is no documentation
    * comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  List<UnlinkedEnumValue> get values => _values ?? const <UnlinkedEnumValue>[];
+  List<UnlinkedEnumValueBuilder> get values => _values ?? const <UnlinkedEnumValue>[];
 
   /**
    * Values listed in the enum declaration, in declaration order.
    */
   void set values(List<UnlinkedEnumValueBuilder> _value) {
     assert(!_finished);
     _values = _value;
   }
 
   UnlinkedEnumBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedEnumValueBuilder> values})
@@ skipping 136 matching lines @@
 
   /**
    * Offset of the enum value name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the enum value, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
@@ skipping 132 matching lines @@
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the offset of the class name (i.e. the
    * offset of the second "C" in "class C { C(); }").
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the executable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRef get returnType => _returnType;
+  TypeRefBuilder get returnType => _returnType;
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void` or the executable is a constructor.  Note that when strong mode is
    * enabled, the actual return type may be different due to type inference.
    */
   void set returnType(TypeRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
-  List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
+  List<UnlinkedParamBuilder> get parameters => _parameters ?? const <UnlinkedParam>[];
 
   /**
    * Parameters of the executable, if any.  Note that getters have no
    * parameters (hence this will be the empty list), and setters have a single
    * parameter.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
@@ skipping 519 matching lines @@
 
   /**
    * URI used in the source code to reference the exported library.
    */
   void set uri(String _value) {
     assert(!_finished);
     _uri = _value;
   }
 
   @override
-  List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
+  List<UnlinkedCombinatorBuilder> get combinators => _combinators ?? const <UnlinkedCombinator>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
   UnlinkedExportPublicBuilder({String uri, List<UnlinkedCombinatorBuilder> combinators})
@@ skipping 119 matching lines @@
    * import declaration, or zero if this import declaration declares no prefix.
    *
    * Note that multiple imports can declare the same prefix.
    */
   void set prefixReference(int _value) {
     assert(!_finished);
     _prefixReference = _value;
   }
 
   @override
-  List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
+  List<UnlinkedCombinatorBuilder> get combinators => _combinators ?? const <UnlinkedCombinator>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
   @override
@@ skipping 286 matching lines @@
 
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  TypeRef get type => _type;
+  TypeRefBuilder get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
   void set type(TypeRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
-  List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
+  List<UnlinkedParamBuilder> get parameters => _parameters ?? const <UnlinkedParam>[];
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
   @override
@@ skipping 479 matching lines @@
 }
 
 class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
   bool _finished = false;
 
   List<UnlinkedPublicNameBuilder> _names;
   List<UnlinkedExportPublicBuilder> _exports;
   List<String> _parts;
 
   @override
-  List<UnlinkedPublicName> get names => _names ?? const <UnlinkedPublicName>[];
+  List<UnlinkedPublicNameBuilder> get names => _names ?? const <UnlinkedPublicName>[];
 
   /**
    * Public names defined in the compilation unit.
    *
    * TODO(paulberry): consider sorting these names to reduce unnecessary
    * relinking.
    */
   void set names(List<UnlinkedPublicNameBuilder> _value) {
     assert(!_finished);
     _names = _value;
   }
 
   @override
-  List<UnlinkedExportPublic> get exports => _exports ?? const <UnlinkedExportPublic>[];
+  List<UnlinkedExportPublicBuilder> get exports => _exports ?? const <UnlinkedExportPublic>[];
 
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
   @override
@@ skipping 261 matching lines @@
 
   /**
    * Offset of the typedef name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the typedef, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
-  TypeRef get returnType => _returnType;
+  TypeRefBuilder get returnType => _returnType;
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
   void set returnType(TypeRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
-  List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
+  List<UnlinkedParamBuilder> get parameters => _parameters ?? const <UnlinkedParam>[];
 
   /**
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
   UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, TypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
@@ skipping 178 matching lines @@
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  TypeRef get bound => _bound;
+  TypeRefBuilder get bound => _bound;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   void set bound(TypeRefBuilder _value) {
     assert(!_finished);
     _bound = _value;
   }
 
@@ skipping 140 matching lines @@
   /**
    * Length of the library name as it appears in the source code (or 0 if the
    * library has no name).
    */
   void set libraryNameLength(int _value) {
     assert(!_finished);
     _libraryNameLength = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get libraryDocumentationComment => _libraryDocumentationComment;
+  UnlinkedDocumentationCommentBuilder get libraryDocumentationComment => _libraryDocumentationComment;
 
   /**
    * Documentation comment for the library, or `null` if there is no
    * documentation comment.
    */
   void set libraryDocumentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _libraryDocumentationComment = _value;
   }
 
   @override
-  UnlinkedPublicNamespace get publicNamespace => _publicNamespace;
+  UnlinkedPublicNamespaceBuilder get publicNamespace => _publicNamespace;
 
   /**
    * Unlinked public namespace of this compilation unit.
    */
   void set publicNamespace(UnlinkedPublicNamespaceBuilder _value) {
     assert(!_finished);
     _publicNamespace = _value;
   }
 
   @override
-  List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
+  List<UnlinkedReferenceBuilder> get references => _references ?? const <UnlinkedReference>[];
 
   /**
    * Top level and prefixed names referred to by this compilation unit.  The
    * zeroth element of this array is always populated and always represents a
    * reference to the pseudo-type "dynamic".
    */
   void set references(List<UnlinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
   @override
-  List<UnlinkedClass> get classes => _classes ?? const <UnlinkedClass>[];
+  List<UnlinkedClassBuilder> get classes => _classes ?? const <UnlinkedClass>[];
 
   /**
    * Classes declared in the compilation unit.
    */
   void set classes(List<UnlinkedClassBuilder> _value) {
     assert(!_finished);
     _classes = _value;
   }
 
   @override
-  List<UnlinkedEnum> get enums => _enums ?? const <UnlinkedEnum>[];
+  List<UnlinkedEnumBuilder> get enums => _enums ?? const <UnlinkedEnum>[];
 
   /**
    * Enums declared in the compilation unit.
    */
   void set enums(List<UnlinkedEnumBuilder> _value) {
     assert(!_finished);
     _enums = _value;
   }
 
   @override
-  List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
+  List<UnlinkedExecutableBuilder> get executables => _executables ?? const <UnlinkedExecutable>[];
 
   /**
    * Top level executable objects (functions, getters, and setters) declared in
    * the compilation unit.
    */
   void set executables(List<UnlinkedExecutableBuilder> _value) {
     assert(!_finished);
     _executables = _value;
   }
 
   @override
-  List<UnlinkedExportNonPublic> get exports => _exports ?? const <UnlinkedExportNonPublic>[];
+  List<UnlinkedExportNonPublicBuilder> get exports => _exports ?? const <UnlinkedExportNonPublic>[];
 
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportNonPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
   @override
-  List<UnlinkedImport> get imports => _imports ?? const <UnlinkedImport>[];
+  List<UnlinkedImportBuilder> get imports => _imports ?? const <UnlinkedImport>[];
 
   /**
    * Import declarations in the compilation unit.
    */
   void set imports(List<UnlinkedImportBuilder> _value) {
     assert(!_finished);
     _imports = _value;
   }
 
   @override
-  List<UnlinkedPart> get parts => _parts ?? const <UnlinkedPart>[];
+  List<UnlinkedPartBuilder> get parts => _parts ?? const <UnlinkedPart>[];
 
   /**
    * Part declarations in the compilation unit.
    */
   void set parts(List<UnlinkedPartBuilder> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
   @override
-  List<UnlinkedTypedef> get typedefs => _typedefs ?? const <UnlinkedTypedef>[];
+  List<UnlinkedTypedefBuilder> get typedefs => _typedefs ?? const <UnlinkedTypedef>[];
 
   /**
    * Typedefs declared in the compilation unit.
    */
   void set typedefs(List<UnlinkedTypedefBuilder> _value) {
     assert(!_finished);
     _typedefs = _value;
   }
 
   @override
-  List<UnlinkedVariable> get variables => _variables ?? const <UnlinkedVariable>[];
+  List<UnlinkedVariableBuilder> get variables => _variables ?? const <UnlinkedVariable>[];
 
   /**
    * Top level variables declared in the compilation unit.
    */
   void set variables(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _variables = _value;
   }
 
   UnlinkedUnitBuilder({String libraryName, int libraryNameOffset, int libraryNameLength, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
@@ skipping 363 matching lines @@
 
   /**
    * Offset of the variable name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationComment get documentationComment => _documentationComment;
+  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
 
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
   @override
-  TypeRef get type => _type;
+  TypeRefBuilder get type => _type;
 
   /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
   void set type(TypeRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
-  UnlinkedConst get constExpr => _constExpr;
+  UnlinkedConstBuilder get constExpr => _constExpr;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.
    */
   void set constExpr(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _constExpr = _value;
   }
 
@@ skipping 289 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }