Make summary builder classes implement summary interfaces.

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 23 matching lines @@
 
 /**
  * Enum used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind {
   required,
   positional,
   named,
 }
 
-class PrelinkedDependencyBuilder {
+class PrelinkedDependencyBuilder extends Object with _PrelinkedDependencyMixin implements PrelinkedDependency {
   bool _finished = false;
 
   String _uri;
   List<String> _parts;
 
   PrelinkedDependencyBuilder();
 
+  @override
+  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>[];
+
   /**
    * 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;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 47 matching lines @@
   List<String> get parts;
 }
 
 class _PrelinkedDependencyReader extends fb.TableReader<_PrelinkedDependencyImpl> {
   const _PrelinkedDependencyReader();
 
   @override
   _PrelinkedDependencyImpl createObject(fb.BufferPointer bp) => new _PrelinkedDependencyImpl(bp);
 }
 
-class _PrelinkedDependencyImpl implements PrelinkedDependency {
+class _PrelinkedDependencyImpl extends Object with _PrelinkedDependencyMixin implements PrelinkedDependency {
   final fb.BufferPointer _bp;
 
   _PrelinkedDependencyImpl(this._bp);
 
   String _uri;
   List<String> _parts;
 
   @override
-  Map<String, Object> toMap() => {
-    "uri": uri,
-    "parts": parts,
-  };
-
-  @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 
   @override
   List<String> get parts {
     _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _parts;
   }
 }
 
-class PrelinkedLibraryBuilder {
+abstract class _PrelinkedDependencyMixin implements PrelinkedDependency {
+  @override
+  Map<String, Object> toMap() => {
+    "uri": uri,
+    "parts": parts,
+  };
+}
+
+class PrelinkedLibraryBuilder extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
   bool _finished = false;
 
   List<PrelinkedUnitBuilder> _units;
   List<PrelinkedDependencyBuilder> _dependencies;
   List<int> _importDependencies;
 
   PrelinkedLibraryBuilder();
 
+  @override
+  List<PrelinkedUnit> get units => _units ?? const <PrelinkedUnit>[];
+
   /**
    * The pre-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<PrelinkedUnitBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
+  @override
+  List<PrelinkedDependency> get dependencies => _dependencies ?? const <PrelinkedDependency>[];
+
   /**
    * 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").
    *
    * TODO(paulberry): consider removing this entirely and just using
    * [UnlinkedLibrary.imports].
    */
   void set dependencies(List<PrelinkedDependencyBuilder> _value) {
     assert(!_finished);
     _dependencies = _value;
   }
 
+  @override
+  List<int> get importDependencies => _importDependencies ?? const <int>[];
+
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
    *
    * TODO(paulberry): if [dependencies] is removed, this can be removed as
    * well, since there will effectively be a one-to-one mapping.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     _importDependencies = _value;
@@ skipping 79 matching lines @@
   List<int> get importDependencies;
 }
 
 class _PrelinkedLibraryReader extends fb.TableReader<_PrelinkedLibraryImpl> {
   const _PrelinkedLibraryReader();
 
   @override
   _PrelinkedLibraryImpl createObject(fb.BufferPointer bp) => new _PrelinkedLibraryImpl(bp);
 }
 
-class _PrelinkedLibraryImpl implements PrelinkedLibrary {
+class _PrelinkedLibraryImpl extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
   final fb.BufferPointer _bp;
 
   _PrelinkedLibraryImpl(this._bp);
 
   List<PrelinkedUnit> _units;
   List<PrelinkedDependency> _dependencies;
   List<int> _importDependencies;
 
   @override
-  Map<String, Object> toMap() => {
-    "units": units,
-    "dependencies": dependencies,
-    "importDependencies": importDependencies,
-  };
-
-  @override
   List<PrelinkedUnit> get units {
     _units ??= const fb.ListReader<PrelinkedUnit>(const _PrelinkedUnitReader()).vTableGet(_bp, 0, const <PrelinkedUnit>[]);
     return _units;
   }
 
   @override
   List<PrelinkedDependency> get dependencies {
     _dependencies ??= const fb.ListReader<PrelinkedDependency>(const _PrelinkedDependencyReader()).vTableGet(_bp, 1, const <PrelinkedDependency>[]);
     return _dependencies;
   }
 
   @override
   List<int> get importDependencies {
     _importDependencies ??= const fb.ListReader<int>(const fb.Int32Reader()).vTableGet(_bp, 2, const <int>[]);
     return _importDependencies;
   }
 }
 
-class PrelinkedReferenceBuilder {
+abstract class _PrelinkedLibraryMixin implements PrelinkedLibrary {
+  @override
+  Map<String, Object> toMap() => {
+    "units": units,
+    "dependencies": dependencies,
+    "importDependencies": importDependencies,
+  };
+}
+
+class PrelinkedReferenceBuilder extends Object with _PrelinkedReferenceMixin implements PrelinkedReference {
   bool _finished = false;
 
   int _dependency;
   PrelinkedReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
 
   PrelinkedReferenceBuilder();
 
+  @override
+  int get dependency => _dependency ?? 0;
+
   /**
    * Index into [PrelinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   void set dependency(int _value) {
     assert(!_finished);
     _dependency = _value;
   }
 
+  @override
+  PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
+
   /**
    * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
    * the kind is [PrelinkedReferenceKind.classOrEnum].
    */
   void set kind(PrelinkedReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
+  @override
+  int get unit => _unit ?? 0;
+
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [PrelinkedLibrary.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);
     _unit = _value;
   }
 
+  @override
+  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);
     _numTypeParameters = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 57 matching lines @@
   int get numTypeParameters;
 }
 
 class _PrelinkedReferenceReader extends fb.TableReader<_PrelinkedReferenceImpl> {
   const _PrelinkedReferenceReader();
 
   @override
   _PrelinkedReferenceImpl createObject(fb.BufferPointer bp) => new _PrelinkedReferenceImpl(bp);
 }
 
-class _PrelinkedReferenceImpl implements PrelinkedReference {
+class _PrelinkedReferenceImpl extends Object with _PrelinkedReferenceMixin implements PrelinkedReference {
   final fb.BufferPointer _bp;
 
   _PrelinkedReferenceImpl(this._bp);
 
   int _dependency;
   PrelinkedReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
 
   @override
-  Map<String, Object> toMap() => {
-    "dependency": dependency,
-    "kind": kind,
-    "unit": unit,
-    "numTypeParameters": numTypeParameters,
-  };
-
-  @override
   int get dependency {
     _dependency ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _dependency;
   }
 
   @override
   PrelinkedReferenceKind get kind {
     _kind ??= PrelinkedReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
     return _kind;
   }
 
   @override
   int get unit {
     _unit ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _unit;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Int32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
 }
 
-class PrelinkedUnitBuilder {
+abstract class _PrelinkedReferenceMixin implements PrelinkedReference {
+  @override
+  Map<String, Object> toMap() => {
+    "dependency": dependency,
+    "kind": kind,
+    "unit": unit,
+    "numTypeParameters": numTypeParameters,
+  };
+}
+
+class PrelinkedUnitBuilder extends Object with _PrelinkedUnitMixin implements PrelinkedUnit {
   bool _finished = false;
 
   List<PrelinkedReferenceBuilder> _references;
 
   PrelinkedUnitBuilder();
 
+  @override
+  List<PrelinkedReference> get references => _references ?? const <PrelinkedReference>[];
+
   /**
    * For each reference in [UnlinkedUnit.references], information about how
    * that reference is resolved.
    */
   void set references(List<PrelinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 29 matching lines @@
   List<PrelinkedReference> get references;
 }
 
 class _PrelinkedUnitReader extends fb.TableReader<_PrelinkedUnitImpl> {
   const _PrelinkedUnitReader();
 
   @override
   _PrelinkedUnitImpl createObject(fb.BufferPointer bp) => new _PrelinkedUnitImpl(bp);
 }
 
-class _PrelinkedUnitImpl implements PrelinkedUnit {
+class _PrelinkedUnitImpl extends Object with _PrelinkedUnitMixin implements PrelinkedUnit {
   final fb.BufferPointer _bp;
 
   _PrelinkedUnitImpl(this._bp);
 
   List<PrelinkedReference> _references;
 
   @override
-  Map<String, Object> toMap() => {
-    "references": references,
-  };
-
-  @override
   List<PrelinkedReference> get references {
     _references ??= const fb.ListReader<PrelinkedReference>(const _PrelinkedReferenceReader()).vTableGet(_bp, 0, const <PrelinkedReference>[]);
     return _references;
   }
 }
 
-class SdkBundleBuilder {
+abstract class _PrelinkedUnitMixin implements PrelinkedUnit {
+  @override
+  Map<String, Object> toMap() => {
+    "references": references,
+  };
+}
+
+class SdkBundleBuilder extends Object with _SdkBundleMixin implements SdkBundle {
   bool _finished = false;
 
   List<String> _prelinkedLibraryUris;
   List<PrelinkedLibraryBuilder> _prelinkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnitBuilder> _unlinkedUnits;
 
   SdkBundleBuilder();
 
+  @override
+  List<String> get prelinkedLibraryUris => _prelinkedLibraryUris ?? const <String>[];
+
   /**
    * The list of URIs of items in [prelinkedLibraries], e.g. `dart:core`.
    */
   void set prelinkedLibraryUris(List<String> _value) {
     assert(!_finished);
     _prelinkedLibraryUris = _value;
   }
 
+  @override
+  List<PrelinkedLibrary> get prelinkedLibraries => _prelinkedLibraries ?? const <PrelinkedLibrary>[];
+
   /**
    * Pre-linked libraries.
    */
   void set prelinkedLibraries(List<PrelinkedLibraryBuilder> _value) {
     assert(!_finished);
     _prelinkedLibraries = _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>[];
+
   /**
    * Unlinked information for the compilation units constituting the SDK.
    */
   void set unlinkedUnits(List<UnlinkedUnitBuilder> _value) {
     assert(!_finished);
     _unlinkedUnits = _value;
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
@@ skipping 75 matching lines @@
   List<UnlinkedUnit> get unlinkedUnits;
 }
 
 class _SdkBundleReader extends fb.TableReader<_SdkBundleImpl> {
   const _SdkBundleReader();
 
   @override
   _SdkBundleImpl createObject(fb.BufferPointer bp) => new _SdkBundleImpl(bp);
 }
 
-class _SdkBundleImpl implements SdkBundle {
+class _SdkBundleImpl extends Object with _SdkBundleMixin implements SdkBundle {
   final fb.BufferPointer _bp;
 
   _SdkBundleImpl(this._bp);
 
   List<String> _prelinkedLibraryUris;
   List<PrelinkedLibrary> _prelinkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnit> _unlinkedUnits;
 
   @override
-  Map<String, Object> toMap() => {
-    "prelinkedLibraryUris": prelinkedLibraryUris,
-    "prelinkedLibraries": prelinkedLibraries,
-    "unlinkedUnitUris": unlinkedUnitUris,
-    "unlinkedUnits": unlinkedUnits,
-  };
-
-  @override
   List<String> get prelinkedLibraryUris {
     _prelinkedLibraryUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
     return _prelinkedLibraryUris;
   }
 
   @override
   List<PrelinkedLibrary> get prelinkedLibraries {
     _prelinkedLibraries ??= const fb.ListReader<PrelinkedLibrary>(const _PrelinkedLibraryReader()).vTableGet(_bp, 1, const <PrelinkedLibrary>[]);
     return _prelinkedLibraries;
   }
 
   @override
   List<String> get unlinkedUnitUris {
     _unlinkedUnitUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
     return _unlinkedUnitUris;
   }
 
   @override
   List<UnlinkedUnit> get unlinkedUnits {
     _unlinkedUnits ??= const fb.ListReader<UnlinkedUnit>(const _UnlinkedUnitReader()).vTableGet(_bp, 3, const <UnlinkedUnit>[]);
     return _unlinkedUnits;
   }
 }
 
-class UnlinkedClassBuilder {
+abstract class _SdkBundleMixin implements SdkBundle {
+  @override
+  Map<String, Object> toMap() => {
+    "prelinkedLibraryUris": prelinkedLibraryUris,
+    "prelinkedLibraries": prelinkedLibraries,
+    "unlinkedUnitUris": unlinkedUnitUris,
+    "unlinkedUnits": unlinkedUnits,
+  };
+}
+
+class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements UnlinkedClass {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   UnlinkedTypeRefBuilder _supertype;
   List<UnlinkedTypeRefBuilder> _mixins;
   List<UnlinkedTypeRefBuilder> _interfaces;
   List<UnlinkedVariableBuilder> _fields;
   List<UnlinkedExecutableBuilder> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   UnlinkedClassBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the class.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  int get nameOffset => _nameOffset ?? 0;
+
   /**
    * 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;
+
   /**
    * 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>[];
+
   /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
+  @override
+  UnlinkedTypeRef 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(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _supertype = _value;
   }
 
+  @override
+  List<UnlinkedTypeRef> get mixins => _mixins ?? const <UnlinkedTypeRef>[];
+
   /**
    * Mixins appearing in a `with` clause, if any.
    */
   void set mixins(List<UnlinkedTypeRefBuilder> _value) {
     assert(!_finished);
     _mixins = _value;
   }
 
+  @override
+  List<UnlinkedTypeRef> get interfaces => _interfaces ?? const <UnlinkedTypeRef>[];
+
   /**
    * Interfaces appearing in an `implements` clause, if any.
    */
   void set interfaces(List<UnlinkedTypeRefBuilder> _value) {
     assert(!_finished);
     _interfaces = _value;
   }
 
+  @override
+  List<UnlinkedVariable> 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>[];
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * Indicates whether this class is the core "Object" class (and hence has no
    * supertype)
    */
   void set hasNoSupertype(bool _value) {
     assert(!_finished);
     _hasNoSupertype = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 159 matching lines @@
   bool get hasNoSupertype;
 }
 
 class _UnlinkedClassReader extends fb.TableReader<_UnlinkedClassImpl> {
   const _UnlinkedClassReader();
 
   @override
   _UnlinkedClassImpl createObject(fb.BufferPointer bp) => new _UnlinkedClassImpl(bp);
 }
 
-class _UnlinkedClassImpl implements UnlinkedClass {
+class _UnlinkedClassImpl extends Object with _UnlinkedClassMixin implements UnlinkedClass {
   final fb.BufferPointer _bp;
 
   _UnlinkedClassImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _supertype;
   List<UnlinkedTypeRef> _mixins;
   List<UnlinkedTypeRef> _interfaces;
   List<UnlinkedVariable> _fields;
   List<UnlinkedExecutable> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "typeParameters": typeParameters,
-    "supertype": supertype,
-    "mixins": mixins,
-    "interfaces": interfaces,
-    "fields": fields,
-    "executables": executables,
-    "isAbstract": isAbstract,
-    "isMixinApplication": isMixinApplication,
-    "hasNoSupertype": hasNoSupertype,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
@@ skipping 52 matching lines @@
     return _isMixinApplication;
   }
 
   @override
   bool get hasNoSupertype {
     _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _hasNoSupertype;
   }
 }
 
-class UnlinkedCombinatorBuilder {
+abstract class _UnlinkedClassMixin implements UnlinkedClass {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+    "typeParameters": typeParameters,
+    "supertype": supertype,
+    "mixins": mixins,
+    "interfaces": interfaces,
+    "fields": fields,
+    "executables": executables,
+    "isAbstract": isAbstract,
+    "isMixinApplication": isMixinApplication,
+    "hasNoSupertype": hasNoSupertype,
+  };
+}
+
+class UnlinkedCombinatorBuilder extends Object with _UnlinkedCombinatorMixin implements UnlinkedCombinator {
   bool _finished = false;
 
   List<String> _shows;
   List<String> _hides;
 
   UnlinkedCombinatorBuilder();
 
+  @override
+  List<String> get shows => _shows ?? const <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 of names which are hidden.  Empty if this is a `show` combinator.
    */
   void set hides(List<String> _value) {
     assert(!_finished);
     _hides = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 41 matching lines @@
   List<String> get hides;
 }
 
 class _UnlinkedCombinatorReader extends fb.TableReader<_UnlinkedCombinatorImpl> {
   const _UnlinkedCombinatorReader();
 
   @override
   _UnlinkedCombinatorImpl createObject(fb.BufferPointer bp) => new _UnlinkedCombinatorImpl(bp);
 }
 
-class _UnlinkedCombinatorImpl implements UnlinkedCombinator {
+class _UnlinkedCombinatorImpl extends Object with _UnlinkedCombinatorMixin implements UnlinkedCombinator {
   final fb.BufferPointer _bp;
 
   _UnlinkedCombinatorImpl(this._bp);
 
   List<String> _shows;
   List<String> _hides;
 
   @override
-  Map<String, Object> toMap() => {
-    "shows": shows,
-    "hides": hides,
-  };
-
-  @override
   List<String> get shows {
     _shows ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
     return _shows;
   }
 
   @override
   List<String> get hides {
     _hides ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _hides;
   }
 }
 
-class UnlinkedDocumentationCommentBuilder {
+abstract class _UnlinkedCombinatorMixin implements UnlinkedCombinator {
+  @override
+  Map<String, Object> toMap() => {
+    "shows": shows,
+    "hides": hides,
+  };
+}
+
+class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements UnlinkedDocumentationComment {
   bool _finished = false;
 
   String _text;
   int _offset;
   int _length;
 
   UnlinkedDocumentationCommentBuilder();
 
+  @override
+  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;
+
   /**
    * Offset of the beginning of the documentation comment relative to the
    * beginning of the file.
    */
   void set offset(int _value) {
     assert(!_finished);
     _offset = _value;
   }
 
+  @override
+  int get length => _length ?? 0;
+
   /**
    * Length of the documentation comment (prior to replacing '\r\n' with '\n').
    */
   void set length(int _value) {
     assert(!_finished);
     _length = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 49 matching lines @@
   int get length;
 }
 
 class _UnlinkedDocumentationCommentReader extends fb.TableReader<_UnlinkedDocumentationCommentImpl> {
   const _UnlinkedDocumentationCommentReader();
 
   @override
   _UnlinkedDocumentationCommentImpl createObject(fb.BufferPointer bp) => new _UnlinkedDocumentationCommentImpl(bp);
 }
 
-class _UnlinkedDocumentationCommentImpl implements UnlinkedDocumentationComment {
+class _UnlinkedDocumentationCommentImpl extends Object with _UnlinkedDocumentationCommentMixin implements UnlinkedDocumentationComment {
   final fb.BufferPointer _bp;
 
   _UnlinkedDocumentationCommentImpl(this._bp);
 
   String _text;
   int _offset;
   int _length;
 
   @override
-  Map<String, Object> toMap() => {
-    "text": text,
-    "offset": offset,
-    "length": length,
-  };
-
-  @override
   String get text {
     _text ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _text;
   }
 
   @override
   int get offset {
     _offset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _offset;
   }
 
   @override
   int get length {
     _length ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _length;
   }
 }
 
-class UnlinkedEnumBuilder {
+abstract class _UnlinkedDocumentationCommentMixin implements UnlinkedDocumentationComment {
+  @override
+  Map<String, Object> toMap() => {
+    "text": text,
+    "offset": offset,
+    "length": length,
+  };
+}
+
+class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements UnlinkedEnum {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedEnumValueBuilder> _values;
 
   UnlinkedEnumBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the enum type.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  int get nameOffset => _nameOffset ?? 0;
+
   /**
    * 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;
+
   /**
    * 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>[];
+
   /**
    * Values listed in the enum declaration, in declaration order.
    */
   void set values(List<UnlinkedEnumValueBuilder> _value) {
     assert(!_finished);
     _values = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 63 matching lines @@
   List<UnlinkedEnumValue> get values;
 }
 
 class _UnlinkedEnumReader extends fb.TableReader<_UnlinkedEnumImpl> {
   const _UnlinkedEnumReader();
 
   @override
   _UnlinkedEnumImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumImpl(bp);
 }
 
-class _UnlinkedEnumImpl implements UnlinkedEnum {
+class _UnlinkedEnumImpl extends Object with _UnlinkedEnumMixin implements UnlinkedEnum {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedEnumValue> _values;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "values": values,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
   List<UnlinkedEnumValue> get values {
     _values ??= const fb.ListReader<UnlinkedEnumValue>(const _UnlinkedEnumValueReader()).vTableGet(_bp, 3, const <UnlinkedEnumValue>[]);
     return _values;
   }
 }
 
-class UnlinkedEnumValueBuilder {
+abstract class _UnlinkedEnumMixin implements UnlinkedEnum {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+    "values": values,
+  };
+}
+
+class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements UnlinkedEnumValue {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
 
   UnlinkedEnumValueBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the enumerated value.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  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);
     _nameOffset = _value;
   }
 
+  @override
+  UnlinkedDocumentationComment 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;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 52 matching lines @@
   UnlinkedDocumentationComment get documentationComment;
 }
 
 class _UnlinkedEnumValueReader extends fb.TableReader<_UnlinkedEnumValueImpl> {
   const _UnlinkedEnumValueReader();
 
   @override
   _UnlinkedEnumValueImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumValueImpl(bp);
 }
 
-class _UnlinkedEnumValueImpl implements UnlinkedEnumValue {
+class _UnlinkedEnumValueImpl extends Object with _UnlinkedEnumValueMixin implements UnlinkedEnumValue {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumValueImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 }
 
-class UnlinkedExecutableBuilder {
+abstract class _UnlinkedEnumValueMixin implements UnlinkedEnumValue {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+  };
+}
+
+class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements UnlinkedExecutable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   UnlinkedTypeRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   UnlinkedExecutableBuilder();
 
+  @override
+  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;
+
   /**
    * 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);
     _nameOffset = _value;
   }
 
+  @override
+  UnlinkedDocumentationComment 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>[];
+
   /**
    * 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
+  UnlinkedTypeRef 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(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
+  @override
+  List<UnlinkedParam> 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;
   }
 
+  @override
+  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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 169 matching lines @@
   bool get isExternal;
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
 
-class _UnlinkedExecutableImpl implements UnlinkedExecutable {
+class _UnlinkedExecutableImpl extends Object with _UnlinkedExecutableMixin implements UnlinkedExecutable {
   final fb.BufferPointer _bp;
 
   _UnlinkedExecutableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "typeParameters": typeParameters,
-    "returnType": returnType,
-    "parameters": parameters,
-    "kind": kind,
-    "isAbstract": isAbstract,
-    "isStatic": isStatic,
-    "isConst": isConst,
-    "isFactory": isFactory,
-    "hasImplicitReturnType": hasImplicitReturnType,
-    "isExternal": isExternal,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
@@ skipping 58 matching lines @@
     return _hasImplicitReturnType;
   }
 
   @override
   bool get isExternal {
     _isExternal ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _isExternal;
   }
 }
 
-class UnlinkedExportNonPublicBuilder {
+abstract class _UnlinkedExecutableMixin implements UnlinkedExecutable {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+    "typeParameters": typeParameters,
+    "returnType": returnType,
+    "parameters": parameters,
+    "kind": kind,
+    "isAbstract": isAbstract,
+    "isStatic": isStatic,
+    "isConst": isConst,
+    "isFactory": isFactory,
+    "hasImplicitReturnType": hasImplicitReturnType,
+    "isExternal": isExternal,
+  };
+}
+
+class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements UnlinkedExportNonPublic {
   bool _finished = false;
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
 
   UnlinkedExportNonPublicBuilder();
 
+  @override
+  int get offset => _offset ?? 0;
+
   /**
    * Offset of the "export" keyword.
    */
   void set offset(int _value) {
     assert(!_finished);
     _offset = _value;
   }
 
+  @override
+  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);
     _uriOffset = _value;
   }
 
+  @override
+  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);
     _uriEnd = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 45 matching lines @@
   int get uriEnd;
 }
 
 class _UnlinkedExportNonPublicReader extends fb.TableReader<_UnlinkedExportNonPublicImpl> {
   const _UnlinkedExportNonPublicReader();
 
   @override
   _UnlinkedExportNonPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportNonPublicImpl(bp);
 }
 
-class _UnlinkedExportNonPublicImpl implements UnlinkedExportNonPublic {
+class _UnlinkedExportNonPublicImpl extends Object with _UnlinkedExportNonPublicMixin implements UnlinkedExportNonPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportNonPublicImpl(this._bp);
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
 
   @override
-  Map<String, Object> toMap() => {
-    "offset": offset,
-    "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-  };
-
-  @override
   int get offset {
     _offset ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _offset;
   }
 
   @override
   int get uriOffset {
     _uriOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _uriOffset;
   }
 
   @override
   int get uriEnd {
     _uriEnd ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _uriEnd;
   }
 }
 
-class UnlinkedExportPublicBuilder {
+abstract class _UnlinkedExportNonPublicMixin implements UnlinkedExportNonPublic {
+  @override
+  Map<String, Object> toMap() => {
+    "offset": offset,
+    "uriOffset": uriOffset,
+    "uriEnd": uriEnd,
+  };
+}
+
+class UnlinkedExportPublicBuilder extends Object with _UnlinkedExportPublicMixin implements UnlinkedExportPublic {
   bool _finished = false;
 
   String _uri;
   List<UnlinkedCombinatorBuilder> _combinators;
 
   UnlinkedExportPublicBuilder();
 
+  @override
+  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>[];
+
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 41 matching lines @@
   List<UnlinkedCombinator> get combinators;
 }
 
 class _UnlinkedExportPublicReader extends fb.TableReader<_UnlinkedExportPublicImpl> {
   const _UnlinkedExportPublicReader();
 
   @override
   _UnlinkedExportPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportPublicImpl(bp);
 }
 
-class _UnlinkedExportPublicImpl implements UnlinkedExportPublic {
+class _UnlinkedExportPublicImpl extends Object with _UnlinkedExportPublicMixin implements UnlinkedExportPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportPublicImpl(this._bp);
 
   String _uri;
   List<UnlinkedCombinator> _combinators;
 
   @override
-  Map<String, Object> toMap() => {
-    "uri": uri,
-    "combinators": combinators,
-  };
-
-  @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 
   @override
   List<UnlinkedCombinator> get combinators {
     _combinators ??= const fb.ListReader<UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 1, const <UnlinkedCombinator>[]);
     return _combinators;
   }
 }
 
-class UnlinkedImportBuilder {
+abstract class _UnlinkedExportPublicMixin implements UnlinkedExportPublic {
+  @override
+  Map<String, Object> toMap() => {
+    "uri": uri,
+    "combinators": combinators,
+  };
+}
+
+class UnlinkedImportBuilder extends Object with _UnlinkedImportMixin implements UnlinkedImport {
   bool _finished = false;
 
   String _uri;
   int _offset;
   int _prefixReference;
   List<UnlinkedCombinatorBuilder> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
   int _prefixOffset;
 
   UnlinkedImportBuilder();
 
+  @override
+  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;
+
   /**
    * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
    * is true, zero.
    */
   void set offset(int _value) {
     assert(!_finished);
     _offset = _value;
   }
 
+  @override
+  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);
     _prefixReference = _value;
   }
 
+  @override
+  List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
+
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
+  @override
+  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;
+
   /**
    * Indicates whether the import declaration is implicit.
    */
   void set isImplicit(bool _value) {
     assert(!_finished);
     _isImplicit = _value;
   }
 
+  @override
+  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);
     _uriOffset = _value;
   }
 
+  @override
+  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);
     _uriEnd = _value;
   }
 
+  @override
+  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);
     _prefixOffset = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 111 matching lines @@
   int get prefixOffset;
 }
 
 class _UnlinkedImportReader extends fb.TableReader<_UnlinkedImportImpl> {
   const _UnlinkedImportReader();
 
   @override
   _UnlinkedImportImpl createObject(fb.BufferPointer bp) => new _UnlinkedImportImpl(bp);
 }
 
-class _UnlinkedImportImpl implements UnlinkedImport {
+class _UnlinkedImportImpl extends Object with _UnlinkedImportMixin implements UnlinkedImport {
   final fb.BufferPointer _bp;
 
   _UnlinkedImportImpl(this._bp);
 
   String _uri;
   int _offset;
   int _prefixReference;
   List<UnlinkedCombinator> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
   int _prefixOffset;
 
   @override
-  Map<String, Object> toMap() => {
-    "uri": uri,
-    "offset": offset,
-    "prefixReference": prefixReference,
-    "combinators": combinators,
-    "isDeferred": isDeferred,
-    "isImplicit": isImplicit,
-    "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-    "prefixOffset": prefixOffset,
-  };
-
-  @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 
   @override
   int get offset {
     _offset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _offset;
   }
@@ skipping 34 matching lines @@
     return _uriEnd;
   }
 
   @override
   int get prefixOffset {
     _prefixOffset ??= const fb.Int32Reader().vTableGet(_bp, 8, 0);
     return _prefixOffset;
   }
 }
 
-class UnlinkedParamBuilder {
+abstract class _UnlinkedImportMixin implements UnlinkedImport {
+  @override
+  Map<String, Object> toMap() => {
+    "uri": uri,
+    "offset": offset,
+    "prefixReference": prefixReference,
+    "combinators": combinators,
+    "isDeferred": isDeferred,
+    "isImplicit": isImplicit,
+    "uriOffset": uriOffset,
+    "uriEnd": uriEnd,
+    "prefixOffset": prefixOffset,
+  };
+}
+
+class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedTypeRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   UnlinkedParamBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  int get nameOffset => _nameOffset ?? 0;
+
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
     assert(!_finished);
     _nameOffset = _value;
   }
 
+  @override
+  UnlinkedTypeRef 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(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
+  @override
+  List<UnlinkedParam> 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
+  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;
+
   /**
    * Indicates whether this is a function-typed parameter.
    */
   void set isFunctionTyped(bool _value) {
     assert(!_finished);
     _isFunctionTyped = _value;
   }
 
+  @override
+  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;
+
   /**
    * 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;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 105 matching lines @@
   bool get hasImplicitType;
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
-class _UnlinkedParamImpl implements UnlinkedParam {
+class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedTypeRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "type": type,
-    "parameters": parameters,
-    "kind": kind,
-    "isFunctionTyped": isFunctionTyped,
-    "isInitializingFormal": isInitializingFormal,
-    "hasImplicitType": hasImplicitType,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
@@ skipping 28 matching lines @@
     return _isInitializingFormal;
   }
 
   @override
   bool get hasImplicitType {
     _hasImplicitType ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _hasImplicitType;
   }
 }
 
-class UnlinkedPartBuilder {
+abstract class _UnlinkedParamMixin implements UnlinkedParam {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "type": type,
+    "parameters": parameters,
+    "kind": kind,
+    "isFunctionTyped": isFunctionTyped,
+    "isInitializingFormal": isInitializingFormal,
+    "hasImplicitType": hasImplicitType,
+  };
+}
+
+class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements UnlinkedPart {
   bool _finished = false;
 
   int _uriOffset;
   int _uriEnd;
 
   UnlinkedPartBuilder();
 
+  @override
+  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);
     _uriOffset = _value;
   }
 
+  @override
+  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);
     _uriEnd = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 35 matching lines @@
   int get uriEnd;
 }
 
 class _UnlinkedPartReader extends fb.TableReader<_UnlinkedPartImpl> {
   const _UnlinkedPartReader();
 
   @override
   _UnlinkedPartImpl createObject(fb.BufferPointer bp) => new _UnlinkedPartImpl(bp);
 }
 
-class _UnlinkedPartImpl implements UnlinkedPart {
+class _UnlinkedPartImpl extends Object with _UnlinkedPartMixin implements UnlinkedPart {
   final fb.BufferPointer _bp;
 
   _UnlinkedPartImpl(this._bp);
 
   int _uriOffset;
   int _uriEnd;
 
   @override
-  Map<String, Object> toMap() => {
-    "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-  };
-
-  @override
   int get uriOffset {
     _uriOffset ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _uriOffset;
   }
 
   @override
   int get uriEnd {
     _uriEnd ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _uriEnd;
   }
 }
 
-class UnlinkedPublicNameBuilder {
+abstract class _UnlinkedPartMixin implements UnlinkedPart {
+  @override
+  Map<String, Object> toMap() => {
+    "uriOffset": uriOffset,
+    "uriEnd": uriEnd,
+  };
+}
+
+class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
   PrelinkedReferenceKind _kind;
   int _numTypeParameters;
 
   UnlinkedPublicNameBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * The name itself.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
+
   /**
    * The kind of object referred to by the name.
    */
   void set kind(PrelinkedReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
+  @override
+  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);
     _numTypeParameters = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 58 matching lines @@
   int get numTypeParameters;
 }
 
 class _UnlinkedPublicNameReader extends fb.TableReader<_UnlinkedPublicNameImpl> {
   const _UnlinkedPublicNameReader();
 
   @override
   _UnlinkedPublicNameImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNameImpl(bp);
 }
 
-class _UnlinkedPublicNameImpl implements UnlinkedPublicName {
+class _UnlinkedPublicNameImpl extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNameImpl(this._bp);
 
   String _name;
   PrelinkedReferenceKind _kind;
   int _numTypeParameters;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "kind": kind,
-    "numTypeParameters": numTypeParameters,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   PrelinkedReferenceKind get kind {
     _kind ??= PrelinkedReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
     return _kind;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _numTypeParameters;
   }
 }
 
-class UnlinkedPublicNamespaceBuilder {
+abstract class _UnlinkedPublicNameMixin implements UnlinkedPublicName {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "kind": kind,
+    "numTypeParameters": numTypeParameters,
+  };
+}
+
+class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
   bool _finished = false;
 
   List<UnlinkedPublicNameBuilder> _names;
   List<UnlinkedExportPublicBuilder> _exports;
   List<String> _parts;
 
   UnlinkedPublicNamespaceBuilder();
 
+  @override
+  List<UnlinkedPublicName> 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>[];
+
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
+  @override
+  List<String> get parts => _parts ?? const <String>[];
+
   /**
    * URIs referenced by part declarations in the compilation unit.
    */
   void set parts(List<String> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
@@ skipping 67 matching lines @@
   List<String> get parts;
 }
 
 class _UnlinkedPublicNamespaceReader extends fb.TableReader<_UnlinkedPublicNamespaceImpl> {
   const _UnlinkedPublicNamespaceReader();
 
   @override
   _UnlinkedPublicNamespaceImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNamespaceImpl(bp);
 }
 
-class _UnlinkedPublicNamespaceImpl implements UnlinkedPublicNamespace {
+class _UnlinkedPublicNamespaceImpl extends Object with _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNamespaceImpl(this._bp);
 
   List<UnlinkedPublicName> _names;
   List<UnlinkedExportPublic> _exports;
   List<String> _parts;
 
   @override
-  Map<String, Object> toMap() => {
-    "names": names,
-    "exports": exports,
-    "parts": parts,
-  };
-
-  @override
   List<UnlinkedPublicName> get names {
     _names ??= const fb.ListReader<UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 0, const <UnlinkedPublicName>[]);
     return _names;
   }
 
   @override
   List<UnlinkedExportPublic> get exports {
     _exports ??= const fb.ListReader<UnlinkedExportPublic>(const _UnlinkedExportPublicReader()).vTableGet(_bp, 1, const <UnlinkedExportPublic>[]);
     return _exports;
   }
 
   @override
   List<String> get parts {
     _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
     return _parts;
   }
 }
 
-class UnlinkedReferenceBuilder {
+abstract class _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
+  @override
+  Map<String, Object> toMap() => {
+    "names": names,
+    "exports": exports,
+    "parts": parts,
+  };
+}
+
+class UnlinkedReferenceBuilder extends Object with _UnlinkedReferenceMixin implements UnlinkedReference {
   bool _finished = false;
 
   String _name;
   int _prefixReference;
 
   UnlinkedReferenceBuilder();
 
+  @override
+  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;
+
   /**
    * 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) {
     assert(!_finished);
@@ skipping 48 matching lines @@
   int get prefixReference;
 }
 
 class _UnlinkedReferenceReader extends fb.TableReader<_UnlinkedReferenceImpl> {
   const _UnlinkedReferenceReader();
 
   @override
   _UnlinkedReferenceImpl createObject(fb.BufferPointer bp) => new _UnlinkedReferenceImpl(bp);
 }
 
-class _UnlinkedReferenceImpl implements UnlinkedReference {
+class _UnlinkedReferenceImpl extends Object with _UnlinkedReferenceMixin implements UnlinkedReference {
   final fb.BufferPointer _bp;
 
   _UnlinkedReferenceImpl(this._bp);
 
   String _name;
   int _prefixReference;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "prefixReference": prefixReference,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get prefixReference {
     _prefixReference ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _prefixReference;
   }
 }
 
-class UnlinkedTypedefBuilder {
+abstract class _UnlinkedReferenceMixin implements UnlinkedReference {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "prefixReference": prefixReference,
+  };
+}
+
+class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements UnlinkedTypedef {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   UnlinkedTypeRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
 
   UnlinkedTypedefBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the typedef.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  int get nameOffset => _nameOffset ?? 0;
+
   /**
    * 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;
+
   /**
    * 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>[];
+
   /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
+  @override
+  UnlinkedTypeRef get returnType => _returnType;
+
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
   void set returnType(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
+  @override
+  List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
+
   /**
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
     _parameters = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 89 matching lines @@
   List<UnlinkedParam> get parameters;
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
   const _UnlinkedTypedefReader();
 
   @override
   _UnlinkedTypedefImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypedefImpl(bp);
 }
 
-class _UnlinkedTypedefImpl implements UnlinkedTypedef {
+class _UnlinkedTypedefImpl extends Object with _UnlinkedTypedefMixin implements UnlinkedTypedef {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypedefImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "typeParameters": typeParameters,
-    "returnType": returnType,
-    "parameters": parameters,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
@@ skipping 16 matching lines @@
     return _returnType;
   }
 
   @override
   List<UnlinkedParam> get parameters {
     _parameters ??= const fb.ListReader<UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 5, const <UnlinkedParam>[]);
     return _parameters;
   }
 }
 
-class UnlinkedTypeParamBuilder {
+abstract class _UnlinkedTypedefMixin implements UnlinkedTypedef {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+    "typeParameters": typeParameters,
+    "returnType": returnType,
+    "parameters": parameters,
+  };
+}
+
+class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedTypeRefBuilder _bound;
 
   UnlinkedTypeParamBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the type parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  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);
     _nameOffset = _value;
   }
 
+  @override
+  UnlinkedTypeRef get bound => _bound;
+
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   void set bound(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _bound = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 51 matching lines @@
   UnlinkedTypeRef get bound;
 }
 
 class _UnlinkedTypeParamReader extends fb.TableReader<_UnlinkedTypeParamImpl> {
   const _UnlinkedTypeParamReader();
 
   @override
   _UnlinkedTypeParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypeParamImpl(bp);
 }
 
-class _UnlinkedTypeParamImpl implements UnlinkedTypeParam {
+class _UnlinkedTypeParamImpl extends Object with _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypeParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedTypeRef _bound;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "bound": bound,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
 
   @override
   UnlinkedTypeRef get bound {
     _bound ??= const _UnlinkedTypeRefReader().vTableGet(_bp, 2, null);
     return _bound;
   }
 }
 
-class UnlinkedTypeRefBuilder {
+abstract class _UnlinkedTypeParamMixin implements UnlinkedTypeParam {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "bound": bound,
+  };
+}
+
+class UnlinkedTypeRefBuilder extends Object with _UnlinkedTypeRefMixin implements UnlinkedTypeRef {
   bool _finished = false;
 
   int _reference;
   int _paramReference;
   List<UnlinkedTypeRefBuilder> _typeArguments;
 
   UnlinkedTypeRefBuilder();
 
+  @override
+  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);
     _reference = _value;
   }
 
+  @override
+  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);
     _paramReference = _value;
   }
 
+  @override
+  List<UnlinkedTypeRef> get typeArguments => _typeArguments ?? const <UnlinkedTypeRef>[];
+
   /**
    * 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<UnlinkedTypeRefBuilder> _value) {
     assert(!_finished);
     _typeArguments = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
@@ skipping 70 matching lines @@
   List<UnlinkedTypeRef> get typeArguments;
 }
 
 class _UnlinkedTypeRefReader extends fb.TableReader<_UnlinkedTypeRefImpl> {
   const _UnlinkedTypeRefReader();
 
   @override
   _UnlinkedTypeRefImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypeRefImpl(bp);
 }
 
-class _UnlinkedTypeRefImpl implements UnlinkedTypeRef {
+class _UnlinkedTypeRefImpl extends Object with _UnlinkedTypeRefMixin implements UnlinkedTypeRef {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypeRefImpl(this._bp);
 
   int _reference;
   int _paramReference;
   List<UnlinkedTypeRef> _typeArguments;
 
   @override
-  Map<String, Object> toMap() => {
-    "reference": reference,
-    "paramReference": paramReference,
-    "typeArguments": typeArguments,
-  };
-
-  @override
   int get reference {
     _reference ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _reference;
   }
 
   @override
   int get paramReference {
     _paramReference ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _paramReference;
   }
 
   @override
   List<UnlinkedTypeRef> get typeArguments {
     _typeArguments ??= const fb.ListReader<UnlinkedTypeRef>(const _UnlinkedTypeRefReader()).vTableGet(_bp, 2, const <UnlinkedTypeRef>[]);
     return _typeArguments;
   }
 }
 
-class UnlinkedUnitBuilder {
+abstract class _UnlinkedTypeRefMixin implements UnlinkedTypeRef {
+  @override
+  Map<String, Object> toMap() => {
+    "reference": reference,
+    "paramReference": paramReference,
+    "typeArguments": typeArguments,
+  };
+}
+
+class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements UnlinkedUnit {
   bool _finished = false;
 
   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;
 
   UnlinkedUnitBuilder();
 
+  @override
+  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;
+
   /**
    * 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);
     _libraryNameOffset = _value;
   }
 
+  @override
+  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);
     _libraryNameLength = _value;
   }
 
+  @override
+  UnlinkedDocumentationComment 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;
+
   /**
    * Unlinked public namespace of this compilation unit.
    */
   void set publicNamespace(UnlinkedPublicNamespaceBuilder _value) {
     assert(!_finished);
     _publicNamespace = _value;
   }
 
+  @override
+  List<UnlinkedReference> 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>[];
+
   /**
    * Classes declared in the compilation unit.
    */
   void set classes(List<UnlinkedClassBuilder> _value) {
     assert(!_finished);
     _classes = _value;
   }
 
+  @override
+  List<UnlinkedEnum> 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>[];
+
   /**
    * 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>[];
+
   /**
    * Export declarations in the compilation unit.
    */
   void set exports(List<UnlinkedExportNonPublicBuilder> _value) {
     assert(!_finished);
     _exports = _value;
   }
 
+  @override
+  List<UnlinkedImport> 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>[];
+
   /**
    * Part declarations in the compilation unit.
    */
   void set parts(List<UnlinkedPartBuilder> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
+  @override
+  List<UnlinkedTypedef> 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>[];
+
   /**
    * Top level variables declared in the compilation unit.
    */
   void set variables(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _variables = _value;
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
@@ skipping 203 matching lines @@
   List<UnlinkedVariable> get variables;
 }
 
 class _UnlinkedUnitReader extends fb.TableReader<_UnlinkedUnitImpl> {
   const _UnlinkedUnitReader();
 
   @override
   _UnlinkedUnitImpl createObject(fb.BufferPointer bp) => new _UnlinkedUnitImpl(bp);
 }
 
-class _UnlinkedUnitImpl implements UnlinkedUnit {
+class _UnlinkedUnitImpl extends Object with _UnlinkedUnitMixin implements UnlinkedUnit {
   final fb.BufferPointer _bp;
 
   _UnlinkedUnitImpl(this._bp);
 
   String _libraryName;
   int _libraryNameOffset;
   int _libraryNameLength;
   UnlinkedDocumentationComment _libraryDocumentationComment;
   UnlinkedPublicNamespace _publicNamespace;
   List<UnlinkedReference> _references;
   List<UnlinkedClass> _classes;
   List<UnlinkedEnum> _enums;
   List<UnlinkedExecutable> _executables;
   List<UnlinkedExportNonPublic> _exports;
   List<UnlinkedImport> _imports;
   List<UnlinkedPart> _parts;
   List<UnlinkedTypedef> _typedefs;
   List<UnlinkedVariable> _variables;
 
   @override
-  Map<String, Object> toMap() => {
-    "libraryName": libraryName,
-    "libraryNameOffset": libraryNameOffset,
-    "libraryNameLength": libraryNameLength,
-    "libraryDocumentationComment": libraryDocumentationComment,
-    "publicNamespace": publicNamespace,
-    "references": references,
-    "classes": classes,
-    "enums": enums,
-    "executables": executables,
-    "exports": exports,
-    "imports": imports,
-    "parts": parts,
-    "typedefs": typedefs,
-    "variables": variables,
-  };
-
-  @override
   String get libraryName {
     _libraryName ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _libraryName;
   }
 
   @override
   int get libraryNameOffset {
     _libraryNameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _libraryNameOffset;
   }
@@ skipping 64 matching lines @@
     return _typedefs;
   }
 
   @override
   List<UnlinkedVariable> get variables {
     _variables ??= const fb.ListReader<UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 13, const <UnlinkedVariable>[]);
     return _variables;
   }
 }
 
-class UnlinkedVariableBuilder {
+abstract class _UnlinkedUnitMixin implements UnlinkedUnit {
+  @override
+  Map<String, Object> toMap() => {
+    "libraryName": libraryName,
+    "libraryNameOffset": libraryNameOffset,
+    "libraryNameLength": libraryNameLength,
+    "libraryDocumentationComment": libraryDocumentationComment,
+    "publicNamespace": publicNamespace,
+    "references": references,
+    "classes": classes,
+    "enums": enums,
+    "executables": executables,
+    "exports": exports,
+    "imports": imports,
+    "parts": parts,
+    "typedefs": typedefs,
+    "variables": variables,
+  };
+}
+
+class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   UnlinkedTypeRefBuilder _type;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
 
   UnlinkedVariableBuilder();
 
+  @override
+  String get name => _name ?? '';
+
   /**
    * Name of the variable.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
+  @override
+  int get nameOffset => _nameOffset ?? 0;
+
   /**
    * 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;
+
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
     assert(!_finished);
     _documentationComment = _value;
   }
 
+  @override
+  UnlinkedTypeRef 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(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
+  @override
+  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;
+
   /**
    * 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;
+
   /**
    * 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;
+
   /**
    * Indicates whether this variable lacks an explicit type declaration.
    */
   void set hasImplicitType(bool _value) {
     assert(!_finished);
     _hasImplicitType = _value;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
@@ skipping 105 matching lines @@
   bool get hasImplicitType;
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
 }
 
-class _UnlinkedVariableImpl implements UnlinkedVariable {
+class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   UnlinkedTypeRef _type;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
 
   @override
-  Map<String, Object> toMap() => {
-    "name": name,
-    "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "type": type,
-    "isStatic": isStatic,
-    "isFinal": isFinal,
-    "isConst": isConst,
-    "hasImplicitType": hasImplicitType,
-  };
-
-  @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
     return _nameOffset;
   }
@@ skipping 28 matching lines @@
     return _isConst;
   }
 
   @override
   bool get hasImplicitType {
     _hasImplicitType ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _hasImplicitType;
   }
 }
 
+abstract class _UnlinkedVariableMixin implements UnlinkedVariable {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "nameOffset": nameOffset,
+    "documentationComment": documentationComment,
+    "type": type,
+    "isStatic": isStatic,
+    "isFinal": isFinal,
+    "isConst": isConst,
+    "hasImplicitType": hasImplicitType,
+  };
+}
+