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 129 matching lines @@
   }
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements LinkedDependency {
   bool _finished = false;
 
   String _uri;
   List<String> _parts;
 
   @override
-  String get uri => _uri ?? '';
+  String get uri => _uri ??= '';
 
   /**
    * The relative URI of the dependent library.  This URI is relative to the
    * importing library, even if there are intervening `export` declarations.
    * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
    * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
    * `b/d/e.dart`.
    */
   void set uri(String _value) {
     assert(!_finished);
     _uri = _value;
   }
 
   @override
-  List<String> get parts => _parts ?? const <String>[];
+  List<String> get parts => _parts ??= <String>[];
 
   /**
    * URI for the compilation units listed in the library's `part` declarations.
    * These URIs are relative to the importing library.
    */
   void set parts(List<String> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
@@ skipping 83 matching lines @@
 
 class LinkedExportNameBuilder extends Object with _LinkedExportNameMixin implements LinkedExportName {
   bool _finished = false;
 
   String _name;
   int _dependency;
   int _unit;
   ReferenceKind _kind;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the exported entity.  TODO(paulberry): do we include the trailing
    * '=' for a setter?
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get dependency => _dependency ?? 0;
+  int get dependency => _dependency ??= 0;
 
   /**
    * Index into [LinkedLibrary.dependencies] for the library in which the
    * entity is defined.
    */
   void set dependency(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _dependency = _value;
   }
 
   @override
-  int get unit => _unit ?? 0;
+  int get unit => _unit ??= 0;
 
   /**
    * Integer index indicating which unit in the exported library contains the
    * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
    */
   void set unit(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _unit = _value;
   }
 
   @override
-  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
+  ReferenceKind get kind => _kind ??= ReferenceKind.classOrEnum;
 
   /**
    * The kind of the entity being referred to.
    */
   void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   LinkedExportNameBuilder({String name, int dependency, int unit, ReferenceKind kind})
@@ skipping 113 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 ??= <LinkedUnitBuilder>[];
 
   /**
    * 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 ??= <LinkedDependencyBuilder>[];
 
   /**
    * 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.
    *
    * A library is only included as a "linked" dependency if it is a true
    * dependency (e.g. a propagated or inferred type or constant value
    * implicitly refers to an element declared in the library) or
    * anti-dependency (e.g. the result of type propagation or type inference
    * depends on the lack of a certain declaration in the library).
    */
   void set dependencies(List<LinkedDependencyBuilder> _value) {
     assert(!_finished);
     _dependencies = _value;
   }
 
   @override
-  List<int> get importDependencies => _importDependencies ?? const <int>[];
+  List<int> get importDependencies => _importDependencies ??= <int>[];
 
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _importDependencies = _value;
   }
 
   @override
-  List<LinkedExportName> get exportNames => _exportNames ?? const <LinkedExportName>[];
+  List<LinkedExportNameBuilder> get exportNames => _exportNames ??= <LinkedExportNameBuilder>[];
 
   /**
    * 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);
     _exportNames = _value;
   }
 
   @override
-  int get numPrelinkedDependencies => _numPrelinkedDependencies ?? 0;
+  int get numPrelinkedDependencies => _numPrelinkedDependencies ??= 0;
 
   /**
    * The number of elements in [dependencies] which are not "linked"
    * dependencies (that is, the number of libraries in the direct imports plus
    * the transitive closure of exports, plus the library itself).
    */
   void set numPrelinkedDependencies(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _numPrelinkedDependencies = _value;
@@ skipping 170 matching lines @@
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements LinkedReference {
   bool _finished = false;
 
   int _dependency;
   ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
   String _name;
 
   @override
-  int get dependency => _dependency ?? 0;
+  int get dependency => _dependency ??= 0;
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   void set dependency(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _dependency = _value;
   }
 
   @override
-  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
+  ReferenceKind get kind => _kind ??= ReferenceKind.classOrEnum;
 
   /**
    * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
    * the kind is [ReferenceKind.classOrEnum].
    */
   void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  int get unit => _unit ?? 0;
+  int get unit => _unit ??= 0;
 
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
    */
   void set unit(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _unit = _value;
   }
 
   @override
-  int get numTypeParameters => _numTypeParameters ?? 0;
+  int get numTypeParameters => _numTypeParameters ??= 0;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
    * name of the entity being referred to.  The empty string refers to the
    * pseudo-type `dynamic`.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
@@ skipping 131 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 ??= <LinkedReferenceBuilder>[];
 
   /**
    * 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 ??= <TypeRefBuilder>[];
 
   /**
    * 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 83 matching lines @@
 
 class SdkBundleBuilder extends Object with _SdkBundleMixin implements SdkBundle {
   bool _finished = false;
 
   List<String> _linkedLibraryUris;
   List<LinkedLibraryBuilder> _linkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnitBuilder> _unlinkedUnits;
 
   @override
-  List<String> get linkedLibraryUris => _linkedLibraryUris ?? const <String>[];
+  List<String> get linkedLibraryUris => _linkedLibraryUris ??= <String>[];
 
   /**
    * 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 ??= <LinkedLibraryBuilder>[];
 
   /**
    * Linked libraries.
    */
   void set linkedLibraries(List<LinkedLibraryBuilder> _value) {
     assert(!_finished);
     _linkedLibraries = _value;
   }
 
   @override
-  List<String> get unlinkedUnitUris => _unlinkedUnitUris ?? const <String>[];
+  List<String> get unlinkedUnitUris => _unlinkedUnitUris ??= <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 ??= <UnlinkedUnitBuilder>[];
 
   /**
    * 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 127 matching lines @@
 
 class TypeRefBuilder extends Object with _TypeRefMixin implements TypeRef {
   bool _finished = false;
 
   int _slot;
   int _reference;
   int _paramReference;
   List<TypeRefBuilder> _typeArguments;
 
   @override
-  int get slot => _slot ?? 0;
+  int get slot => _slot ??= 0;
 
   /**
    * If this [TypeRef] is contained within [LinkedUnit.types], slot id (which
    * is unique within the compilation unit) identifying the target of type
    * propagation or type inference with which this [TypeRef] is associated.
    *
    * Otherwise zero.
    */
   void set slot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _slot = _value;
   }
 
   @override
-  int get reference => _reference ?? 0;
+  int get reference => _reference ??= 0;
 
   /**
    * Index into [UnlinkedUnit.references] for the type being referred to, or
    * zero if this is a reference to a type parameter.
    *
    * Note that since zero is also a valid index into
    * [UnlinkedUnit.references], we cannot distinguish between references to
    * type parameters and references to types by checking [reference] against
    * zero.  To distinguish between references to type parameters and references
    * to types, check whether [paramReference] is zero.
    */
   void set reference(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _reference = _value;
   }
 
   @override
-  int get paramReference => _paramReference ?? 0;
+  int get paramReference => _paramReference ??= 0;
 
   /**
    * If this is a reference to a type parameter, one-based index into the list
    * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
    * Bruijn index conventions; that is, innermost parameters come first, and
    * if a class or method has multiple parameters, they are indexed from right
    * to left.  So for instance, if the enclosing declaration is
    *
    *     class C<T,U> {
    *       m<V,W> {
    *         ...
    *       }
    *     }
    *
    * Then [paramReference] values of 1, 2, 3, and 4 represent W, V, U, and T,
    * respectively.
    *
    * If the type being referred to is not a type parameter, [paramReference] is
    * zero.
    */
   void set paramReference(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _paramReference = _value;
   }
 
   @override
-  List<TypeRef> get typeArguments => _typeArguments ?? const <TypeRef>[];
+  List<TypeRefBuilder> get typeArguments => _typeArguments ??= <TypeRefBuilder>[];
 
   /**
    * 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 143 matching lines @@
   TypeRefBuilder _supertype;
   List<TypeRefBuilder> _mixins;
   List<TypeRefBuilder> _interfaces;
   List<UnlinkedVariableBuilder> _fields;
   List<UnlinkedExecutableBuilder> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the class.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the class name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * 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 ??= <TypeRefBuilder>[];
 
   /**
    * 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 ??= <TypeRefBuilder>[];
 
   /**
    * 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 ??= <UnlinkedVariableBuilder>[];
 
   /**
    * 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 ??= <UnlinkedExecutableBuilder>[];
 
   /**
    * Executable objects (methods, getters, and setters) contained in the class.
    */
   void set executables(List<UnlinkedExecutableBuilder> _value) {
     assert(!_finished);
     _executables = _value;
   }
 
   @override
-  bool get isAbstract => _isAbstract ?? false;
+  bool get isAbstract => _isAbstract ??= false;
 
   /**
    * Indicates whether the class is declared with the `abstract` keyword.
    */
   void set isAbstract(bool _value) {
     assert(!_finished);
     _isAbstract = _value;
   }
 
   @override
-  bool get isMixinApplication => _isMixinApplication ?? false;
+  bool get isMixinApplication => _isMixinApplication ??= false;
 
   /**
    * Indicates whether the class is declared using mixin application syntax.
    */
   void set isMixinApplication(bool _value) {
     assert(!_finished);
     _isMixinApplication = _value;
   }
 
   @override
-  bool get hasNoSupertype => _hasNoSupertype ?? false;
+  bool get hasNoSupertype => _hasNoSupertype ??= false;
 
   /**
    * Indicates whether this class is the core "Object" class (and hence has no
    * supertype)
    */
   void set hasNoSupertype(bool _value) {
     assert(!_finished);
     _hasNoSupertype = _value;
   }
 
@@ skipping 273 matching lines @@
   };
 }
 
 class UnlinkedCombinatorBuilder extends Object with _UnlinkedCombinatorMixin implements UnlinkedCombinator {
   bool _finished = false;
 
   List<String> _shows;
   List<String> _hides;
 
   @override
-  List<String> get shows => _shows ?? const <String>[];
+  List<String> get shows => _shows ??= <String>[];
 
   /**
    * List of names which are shown.  Empty if this is a `hide` combinator.
    */
   void set shows(List<String> _value) {
     assert(!_finished);
     _shows = _value;
   }
 
   @override
-  List<String> get hides => _hides ?? const <String>[];
+  List<String> get hides => _hides ??= <String>[];
 
   /**
    * List of names which are hidden.  Empty if this is a `show` combinator.
    */
   void set hides(List<String> _value) {
     assert(!_finished);
     _hides = _value;
   }
 
   UnlinkedCombinatorBuilder({List<String> shows, List<String> hides})
@@ skipping 78 matching lines @@
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements UnlinkedConst {
   bool _finished = false;
 
   List<UnlinkedConstOperation> _operations;
   List<int> _ints;
   List<double> _doubles;
   List<String> _strings;
   List<TypeRefBuilder> _references;
 
   @override
-  List<UnlinkedConstOperation> get operations => _operations ?? const <UnlinkedConstOperation>[];
+  List<UnlinkedConstOperation> get operations => _operations ??= <UnlinkedConstOperation>[];
 
   /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   void set operations(List<UnlinkedConstOperation> _value) {
     assert(!_finished);
     _operations = _value;
   }
 
   @override
-  List<int> get ints => _ints ?? const <int>[];
+  List<int> get ints => _ints ??= <int>[];
 
   /**
    * Sequence of unsigned 32-bit integers consumed by the operations
    * `pushArgument`, `pushInt`, `shiftOr`, `concatenate`, `invokeConstructor`,
    * `makeList`, and `makeMap`.
    */
   void set ints(List<int> _value) {
     assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _ints = _value;
   }
 
   @override
-  List<double> get doubles => _doubles ?? const <double>[];
+  List<double> get doubles => _doubles ??= <double>[];
 
   /**
    * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
    */
   void set doubles(List<double> _value) {
     assert(!_finished);
     _doubles = _value;
   }
 
   @override
-  List<String> get strings => _strings ?? const <String>[];
+  List<String> get strings => _strings ??= <String>[];
 
   /**
    * 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 ??= <TypeRefBuilder>[];
 
   /**
    * 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 155 matching lines @@
 }
 
 class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements UnlinkedDocumentationComment {
   bool _finished = false;
 
   String _text;
   int _offset;
   int _length;
 
   @override
-  String get text => _text ?? '';
+  String get text => _text ??= '';
 
   /**
    * Text of the documentation comment, with '\r\n' replaced by '\n'.
    *
    * References appearing within the doc comment in square brackets are not
    * specially encoded.
    */
   void set text(String _value) {
     assert(!_finished);
     _text = _value;
   }
 
   @override
-  int get offset => _offset ?? 0;
+  int get offset => _offset ??= 0;
 
   /**
    * Offset of the beginning of the documentation comment relative to the
    * beginning of the file.
    */
   void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
-  int get length => _length ?? 0;
+  int get length => _length ??= 0;
 
   /**
    * Length of the documentation comment (prior to replacing '\r\n' with '\n').
    */
   void set length(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _length = _value;
   }
 
@@ skipping 94 matching lines @@
 
 class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements UnlinkedEnum {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedEnumValueBuilder> _values;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the enum type.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the enum name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedEnumValueBuilder>[];
 
   /**
    * 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 114 matching lines @@
 }
 
 class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements UnlinkedEnumValue {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the enumerated value.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the enum value name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 105 matching lines @@
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the executable name relative to the beginning of the file.  For
    * 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);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * 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 ??= <UnlinkedParamBuilder>[];
 
   /**
    * 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;
   }
 
   @override
-  UnlinkedExecutableKind get kind => _kind ?? UnlinkedExecutableKind.functionOrMethod;
+  UnlinkedExecutableKind get kind => _kind ??= UnlinkedExecutableKind.functionOrMethod;
 
   /**
    * The kind of the executable (function/method, getter, setter, or
    * constructor).
    */
   void set kind(UnlinkedExecutableKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  bool get isAbstract => _isAbstract ?? false;
+  bool get isAbstract => _isAbstract ??= false;
 
   /**
    * Indicates whether the executable is declared using the `abstract` keyword.
    */
   void set isAbstract(bool _value) {
     assert(!_finished);
     _isAbstract = _value;
   }
 
   @override
-  bool get isStatic => _isStatic ?? false;
+  bool get isStatic => _isStatic ??= false;
 
   /**
    * Indicates whether the executable is declared using the `static` keyword.
    *
    * Note that for top level executables, this flag is false, since they are
    * not declared using the `static` keyword (even though they are considered
    * static for semantic purposes).
    */
   void set isStatic(bool _value) {
     assert(!_finished);
     _isStatic = _value;
   }
 
   @override
-  bool get isConst => _isConst ?? false;
+  bool get isConst => _isConst ??= false;
 
   /**
    * Indicates whether the executable is declared using the `const` keyword.
    */
   void set isConst(bool _value) {
     assert(!_finished);
     _isConst = _value;
   }
 
   @override
-  bool get isFactory => _isFactory ?? false;
+  bool get isFactory => _isFactory ??= false;
 
   /**
    * Indicates whether the executable is declared using the `factory` keyword.
    */
   void set isFactory(bool _value) {
     assert(!_finished);
     _isFactory = _value;
   }
 
   @override
-  bool get hasImplicitReturnType => _hasImplicitReturnType ?? false;
+  bool get hasImplicitReturnType => _hasImplicitReturnType ??= false;
 
   /**
    * Indicates whether the executable lacks an explicit return type
    * declaration.  False for constructors and setters.
    */
   void set hasImplicitReturnType(bool _value) {
     assert(!_finished);
     _hasImplicitReturnType = _value;
   }
 
   @override
-  bool get isExternal => _isExternal ?? false;
+  bool get isExternal => _isExternal ??= false;
 
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
   UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, TypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType, bool isExternal})
@@ skipping 292 matching lines @@
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements UnlinkedExportNonPublic {
   bool _finished = false;
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
 
   @override
-  int get offset => _offset ?? 0;
+  int get offset => _offset ??= 0;
 
   /**
    * Offset of the "export" keyword.
    */
   void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
-  int get uriOffset => _uriOffset ?? 0;
+  int get uriOffset => _uriOffset ??= 0;
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
    */
   void set uriOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriOffset = _value;
   }
 
   @override
-  int get uriEnd => _uriEnd ?? 0;
+  int get uriEnd => _uriEnd ??= 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
@@ skipping 88 matching lines @@
   };
 }
 
 class UnlinkedExportPublicBuilder extends Object with _UnlinkedExportPublicMixin implements UnlinkedExportPublic {
   bool _finished = false;
 
   String _uri;
   List<UnlinkedCombinatorBuilder> _combinators;
 
   @override
-  String get uri => _uri ?? '';
+  String get uri => _uri ??= '';
 
   /**
    * 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 ??= <UnlinkedCombinatorBuilder>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
   UnlinkedExportPublicBuilder({String uri, List<UnlinkedCombinatorBuilder> combinators})
@@ skipping 82 matching lines @@
   int _offset;
   int _prefixReference;
   List<UnlinkedCombinatorBuilder> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
   int _prefixOffset;
 
   @override
-  String get uri => _uri ?? '';
+  String get uri => _uri ??= '';
 
   /**
    * URI used in the source code to reference the imported library.
    */
   void set uri(String _value) {
     assert(!_finished);
     _uri = _value;
   }
 
   @override
-  int get offset => _offset ?? 0;
+  int get offset => _offset ??= 0;
 
   /**
    * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
    * is true, zero.
    */
   void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
-  int get prefixReference => _prefixReference ?? 0;
+  int get prefixReference => _prefixReference ??= 0;
 
   /**
    * Index into [UnlinkedUnit.references] of the prefix declared by this
    * 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);
     assert(_value == null || _value >= 0);
     _prefixReference = _value;
   }
 
   @override
-  List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
+  List<UnlinkedCombinatorBuilder> get combinators => _combinators ??= <UnlinkedCombinatorBuilder>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
   @override
-  bool get isDeferred => _isDeferred ?? false;
+  bool get isDeferred => _isDeferred ??= false;
 
   /**
    * Indicates whether the import declaration uses the `deferred` keyword.
    */
   void set isDeferred(bool _value) {
     assert(!_finished);
     _isDeferred = _value;
   }
 
   @override
-  bool get isImplicit => _isImplicit ?? false;
+  bool get isImplicit => _isImplicit ??= false;
 
   /**
    * Indicates whether the import declaration is implicit.
    */
   void set isImplicit(bool _value) {
     assert(!_finished);
     _isImplicit = _value;
   }
 
   @override
-  int get uriOffset => _uriOffset ?? 0;
+  int get uriOffset => _uriOffset ??= 0;
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.  If [isImplicit] is true, zero.
    */
   void set uriOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriOffset = _value;
   }
 
   @override
-  int get uriEnd => _uriEnd ?? 0;
+  int get uriEnd => _uriEnd ??= 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.  If [isImplicit] is true, zero.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
 
   @override
-  int get prefixOffset => _prefixOffset ?? 0;
+  int get prefixOffset => _prefixOffset ??= 0;
 
   /**
    * Offset of the prefix name relative to the beginning of the file, or zero
    * if there is no prefix.
    */
   void set prefixOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _prefixOffset = _value;
   }
@@ skipping 208 matching lines @@
   String _name;
   int _nameOffset;
   TypeRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedParamBuilder>[];
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
   @override
-  UnlinkedParamKind get kind => _kind ?? UnlinkedParamKind.required;
+  UnlinkedParamKind get kind => _kind ??= UnlinkedParamKind.required;
 
   /**
    * Kind of the parameter.
    */
   void set kind(UnlinkedParamKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  bool get isFunctionTyped => _isFunctionTyped ?? false;
+  bool get isFunctionTyped => _isFunctionTyped ??= false;
 
   /**
    * Indicates whether this is a function-typed parameter.
    */
   void set isFunctionTyped(bool _value) {
     assert(!_finished);
     _isFunctionTyped = _value;
   }
 
   @override
-  bool get isInitializingFormal => _isInitializingFormal ?? false;
+  bool get isInitializingFormal => _isInitializingFormal ??= false;
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
    * declared using `this.` syntax).
    */
   void set isInitializingFormal(bool _value) {
     assert(!_finished);
     _isInitializingFormal = _value;
   }
 
   @override
-  bool get hasImplicitType => _hasImplicitType ?? false;
+  bool get hasImplicitType => _hasImplicitType ??= false;
 
   /**
    * Indicates whether this parameter lacks an explicit type declaration.
    * Always false for a function-typed parameter.
    */
   void set hasImplicitType(bool _value) {
     assert(!_finished);
     _hasImplicitType = _value;
   }
 
@@ skipping 187 matching lines @@
   };
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements UnlinkedPart {
   bool _finished = false;
 
   int _uriOffset;
   int _uriEnd;
 
   @override
-  int get uriOffset => _uriOffset ?? 0;
+  int get uriOffset => _uriOffset ??= 0;
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
    */
   void set uriOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriOffset = _value;
   }
 
   @override
-  int get uriEnd => _uriEnd ?? 0;
+  int get uriEnd => _uriEnd ??= 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
@@ skipping 71 matching lines @@
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
   ReferenceKind _kind;
   int _numTypeParameters;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * The name itself.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
+  ReferenceKind get kind => _kind ??= ReferenceKind.classOrEnum;
 
   /**
    * The kind of object referred to by the name.
    */
   void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  int get numTypeParameters => _numTypeParameters ?? 0;
+  int get numTypeParameters => _numTypeParameters ??= 0;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
@@ skipping 102 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 ??= <UnlinkedPublicNameBuilder>[];
 
   /**
    * 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 ??= <UnlinkedExportPublicBuilder>[];
 
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
   @override
-  List<String> get parts => _parts ?? const <String>[];
+  List<String> get parts => _parts ??= <String>[];
 
   /**
    * URIs referenced by part declarations in the compilation unit.
    */
   void set parts(List<String> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
   UnlinkedPublicNamespaceBuilder({List<UnlinkedPublicNameBuilder> names, List<UnlinkedExportPublicBuilder> exports, List<String> parts})
@@ skipping 109 matching lines @@
   };
 }
 
 class UnlinkedReferenceBuilder extends Object with _UnlinkedReferenceMixin implements UnlinkedReference {
   bool _finished = false;
 
   String _name;
   int _prefixReference;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the entity being referred to.  The empty string refers to the
    * pseudo-type `dynamic`.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get prefixReference => _prefixReference ?? 0;
+  int get prefixReference => _prefixReference ??= 0;
 
   /**
    * Prefix used to refer to the entity, or zero if no prefix is used.  This is
    * an index into [UnlinkedUnit.references].
    *
    * Prefix references must always point backward; that is, for all i, if
    * UnlinkedUnit.references[i].prefixReference != 0, then
    * UnlinkedUnit.references[i].prefixReference < i.
    */
   void set prefixReference(int _value) {
@@ skipping 87 matching lines @@
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   TypeRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the typedef.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the typedef name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * 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 ??= <UnlinkedParamBuilder>[];
 
   /**
    * 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 156 matching lines @@
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   TypeRefBuilder _bound;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the type parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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 105 matching lines @@
   List<UnlinkedClassBuilder> _classes;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
   List<UnlinkedImportBuilder> _imports;
   List<UnlinkedPartBuilder> _parts;
   List<UnlinkedTypedefBuilder> _typedefs;
   List<UnlinkedVariableBuilder> _variables;
 
   @override
-  String get libraryName => _libraryName ?? '';
+  String get libraryName => _libraryName ??= '';
 
   /**
    * Name of the library (from a "library" declaration, if present).
    */
   void set libraryName(String _value) {
     assert(!_finished);
     _libraryName = _value;
   }
 
   @override
-  int get libraryNameOffset => _libraryNameOffset ?? 0;
+  int get libraryNameOffset => _libraryNameOffset ??= 0;
 
   /**
    * Offset of the library name relative to the beginning of the file (or 0 if
    * the library has no name).
    */
   void set libraryNameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _libraryNameOffset = _value;
   }
 
   @override
-  int get libraryNameLength => _libraryNameLength ?? 0;
+  int get libraryNameLength => _libraryNameLength ??= 0;
 
   /**
    * 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);
     assert(_value == null || _value >= 0);
     _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 ??= <UnlinkedReferenceBuilder>[];
 
   /**
    * 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 ??= <UnlinkedClassBuilder>[];
 
   /**
    * 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 ??= <UnlinkedEnumBuilder>[];
 
   /**
    * 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 ??= <UnlinkedExecutableBuilder>[];
 
   /**
    * 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 ??= <UnlinkedExportNonPublicBuilder>[];
 
   /**
    * 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 ??= <UnlinkedImportBuilder>[];
 
   /**
    * 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 ??= <UnlinkedPartBuilder>[];
 
   /**
    * 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 ??= <UnlinkedTypedefBuilder>[];
 
   /**
    * 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 ??= <UnlinkedVariableBuilder>[];
 
   /**
    * 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 341 matching lines @@
   UnlinkedDocumentationCommentBuilder _documentationComment;
   TypeRefBuilder _type;
   UnlinkedConstBuilder _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
   int _propagatedTypeSlot;
 
   @override
-  String get name => _name ?? '';
+  String get name => _name ??= '';
 
   /**
    * Name of the variable.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ?? 0;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the variable name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _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;
   }
 
   @override
-  bool get isStatic => _isStatic ?? false;
+  bool get isStatic => _isStatic ??= false;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
    * Note that for top level variables, this flag is false, since they are not
    * declared using the `static` keyword (even though they are considered
    * static for semantic purposes).
    */
   void set isStatic(bool _value) {
     assert(!_finished);
     _isStatic = _value;
   }
 
   @override
-  bool get isFinal => _isFinal ?? false;
+  bool get isFinal => _isFinal ??= false;
 
   /**
    * Indicates whether the variable is declared using the `final` keyword.
    */
   void set isFinal(bool _value) {
     assert(!_finished);
     _isFinal = _value;
   }
 
   @override
-  bool get isConst => _isConst ?? false;
+  bool get isConst => _isConst ??= false;
 
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   void set isConst(bool _value) {
     assert(!_finished);
     _isConst = _value;
   }
 
   @override
-  bool get hasImplicitType => _hasImplicitType ?? false;
+  bool get hasImplicitType => _hasImplicitType ??= false;
 
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   void set hasImplicitType(bool _value) {
     assert(!_finished);
     _hasImplicitType = _value;
   }
 
   @override
-  int get propagatedTypeSlot => _propagatedTypeSlot ?? 0;
+  int get propagatedTypeSlot => _propagatedTypeSlot ??= 0;
 
   /**
    * If this variable is propagable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the propagated type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then this variable's
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   void set propagatedTypeSlot(int _value) {
@@ skipping 230 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }