Sort members in idl.dart.

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 'flat_buffers.dart' as fb;
@@ skipping 60 matching lines @@
   @override
   idl.UnlinkedParamKind read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return idl.UnlinkedParamKind.values[index];
   }
 }
 
 class EntityRefBuilder extends Object with _EntityRefMixin implements idl.EntityRef {
   bool _finished = false;
 
+  List<int> _implicitFunctionTypeIndices;
+  int _paramReference;
+  int _reference;
   int _slot;
-  int _reference;
-  int _paramReference;
-  List<int> _implicitFunctionTypeIndices;
   List<EntityRefBuilder> _typeArguments;
 
   @override
-  int get slot => _slot ??= 0;
+  List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
 
   /**
-   * If this [EntityRef] 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 [EntityRef] is associated.
+   * If this is a reference to a function type implicitly defined by a
+   * function-typed parameter, a list of zero-based indices indicating the path
+   * from the entity referred to by [reference] to the appropriate type
+   * parameter.  Otherwise the empty list.
    *
-   * Otherwise zero.
+   * If there are N indices in this list, then the entity being referred to is
+   * the function type implicitly defined by a function-typed parameter of a
+   * function-typed parameter, to N levels of nesting.  The first index in the
+   * list refers to the outermost level of nesting; for example if [reference]
+   * refers to the entity defined by:
+   *
+   *     void f(x, void g(y, z, int h(String w))) { ... }
+   *
+   * Then to refer to the function type implicitly defined by parameter `h`
+   * (which is parameter 2 of parameter 1 of `f`), then
+   * [implicitFunctionTypeIndices] should be [1, 2].
+   *
+   * Note that if the entity being referred to is a generic method inside a
+   * generic class, then the type arguments in [typeArguments] are applied
+   * first to the class and then to the method.
    */
-  void set slot(int _value) {
+  void set implicitFunctionTypeIndices(List<int> _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _slot = _value;
+    assert(_value == null || _value.every((e) => e >= 0));
+    _implicitFunctionTypeIndices = _value;
   }
 
   @override
-  int get reference => _reference ??= 0;
-
-  /**
-   * Index into [UnlinkedUnit.references] for the entity being referred to, or
-   * zero if this is a reference to a type parameter.
-   */
-  void set reference(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _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);
     assert(_value == null || _value >= 0);
     _paramReference = _value;
   }
 
   @override
-  List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
+  int get reference => _reference ??= 0;
 
   /**
-   * If this is a reference to a function type implicitly defined by a
-   * function-typed parameter, a list of zero-based indices indicating the path
-   * from the entity referred to by [reference] to the appropriate type
-   * parameter.  Otherwise the empty list.
-   *
-   * If there are N indices in this list, then the entity being referred to is
-   * the function type implicitly defined by a function-typed parameter of a
-   * function-typed parameter, to N levels of nesting.  The first index in the
-   * list refers to the outermost level of nesting; for example if [reference]
-   * refers to the entity defined by:
-   *
-   *     void f(x, void g(y, z, int h(String w))) { ... }
-   *
-   * Then to refer to the function type implicitly defined by parameter `h`
-   * (which is parameter 2 of parameter 1 of `f`), then
-   * [implicitFunctionTypeIndices] should be [1, 2].
-   *
-   * Note that if the entity being referred to is a generic method inside a
-   * generic class, then the type arguments in [typeArguments] are applied
-   * first to the class and then to the method.
+   * Index into [UnlinkedUnit.references] for the entity being referred to, or
+   * zero if this is a reference to a type parameter.
    */
-  void set implicitFunctionTypeIndices(List<int> _value) {
+  void set reference(int _value) {
     assert(!_finished);
-    assert(_value == null || _value.every((e) => e >= 0));
-    _implicitFunctionTypeIndices = _value;
+    assert(_value == null || _value >= 0);
+    _reference = _value;
   }
 
   @override
+  int get slot => _slot ??= 0;
+
+  /**
+   * If this [EntityRef] 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 [EntityRef] is associated.
+   *
+   * Otherwise zero.
+   */
+  void set slot(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _slot = _value;
+  }
+
+  @override
   List<EntityRefBuilder> get typeArguments => _typeArguments ??= <EntityRefBuilder>[];
 
   /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it.  Trailing type arguments of type
    * `dynamic` are omitted.
    */
   void set typeArguments(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _typeArguments = _value;
   }
 
-  EntityRefBuilder({int slot, int reference, int paramReference, List<int> implicitFunctionTypeIndices, List<EntityRefBuilder> typeArguments})
-    : _slot = slot,
+  EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<EntityRefBuilder> typeArguments})
+    : _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
+      _paramReference = paramReference,
       _reference = reference,
-      _paramReference = paramReference,
-      _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
+      _slot = slot,
       _typeArguments = typeArguments;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_typeArguments;
     if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
       offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
     }
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
-    if (_slot != null && _slot != 0) {
-      fbBuilder.addUint32(0, _slot);
+    if (offset_implicitFunctionTypeIndices != null) {
+      fbBuilder.addOffset(0, offset_implicitFunctionTypeIndices);
+    }
+    if (_paramReference != null && _paramReference != 0) {
+      fbBuilder.addUint32(1, _paramReference);
     }
     if (_reference != null && _reference != 0) {
-      fbBuilder.addUint32(1, _reference);
+      fbBuilder.addUint32(2, _reference);
     }
-    if (_paramReference != null && _paramReference != 0) {
-      fbBuilder.addUint32(2, _paramReference);
-    }
-    if (offset_implicitFunctionTypeIndices != null) {
-      fbBuilder.addOffset(3, offset_implicitFunctionTypeIndices);
+    if (_slot != null && _slot != 0) {
+      fbBuilder.addUint32(3, _slot);
     }
     if (offset_typeArguments != null) {
       fbBuilder.addOffset(4, offset_typeArguments);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _EntityRefReader extends fb.TableReader<_EntityRefImpl> {
   const _EntityRefReader();
 
   @override
   _EntityRefImpl createObject(fb.BufferPointer bp) => new _EntityRefImpl(bp);
 }
 
 class _EntityRefImpl extends Object with _EntityRefMixin implements idl.EntityRef {
   final fb.BufferPointer _bp;
 
   _EntityRefImpl(this._bp);
 
+  List<int> _implicitFunctionTypeIndices;
+  int _paramReference;
+  int _reference;
   int _slot;
-  int _reference;
-  int _paramReference;
-  List<int> _implicitFunctionTypeIndices;
   List<idl.EntityRef> _typeArguments;
 
   @override
+  List<int> get implicitFunctionTypeIndices {
+    _implicitFunctionTypeIndices ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 0, const <int>[]);
+    return _implicitFunctionTypeIndices;
+  }
+
+  @override
+  int get paramReference {
+    _paramReference ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    return _paramReference;
+  }
+
+  @override
+  int get reference {
+    _reference ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    return _reference;
+  }
+
+  @override
   int get slot {
-    _slot ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    _slot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _slot;
   }
 
   @override
-  int get reference {
-    _reference ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _reference;
-  }
-
-  @override
-  int get paramReference {
-    _paramReference ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
-    return _paramReference;
-  }
-
-  @override
-  List<int> get implicitFunctionTypeIndices {
-    _implicitFunctionTypeIndices ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 3, const <int>[]);
-    return _implicitFunctionTypeIndices;
-  }
-
-  @override
   List<idl.EntityRef> get typeArguments {
     _typeArguments ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <idl.EntityRef>[]);
     return _typeArguments;
   }
 }
 
 abstract class _EntityRefMixin implements idl.EntityRef {
   @override
   Map<String, Object> toMap() => {
+    "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
+    "paramReference": paramReference,
+    "reference": reference,
     "slot": slot,
-    "reference": reference,
-    "paramReference": paramReference,
-    "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
     "typeArguments": typeArguments,
   };
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
   bool _finished = false;
 
+  List<String> _parts;
   String _uri;
-  List<String> _parts;
+
+  @override
+  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;
+  }
 
   @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 ??= <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;
-  }
-
-  LinkedDependencyBuilder({String uri, List<String> parts})
-    : _uri = uri,
-      _parts = parts;
+  LinkedDependencyBuilder({List<String> parts, String uri})
+    : _parts = parts,
+      _uri = uri;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_parts;
     fb.Offset offset_uri;
-    fb.Offset offset_parts;
+    if (!(_parts == null || _parts.isEmpty)) {
+      offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
+    }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
-    if (!(_parts == null || _parts.isEmpty)) {
-      offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
+    fbBuilder.startTable();
+    if (offset_parts != null) {
+      fbBuilder.addOffset(0, offset_parts);
     }
-    fbBuilder.startTable();
     if (offset_uri != null) {
-      fbBuilder.addOffset(0, offset_uri);
-    }
-    if (offset_parts != null) {
-      fbBuilder.addOffset(1, offset_parts);
+      fbBuilder.addOffset(1, offset_uri);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedDependencyReader extends fb.TableReader<_LinkedDependencyImpl> {
   const _LinkedDependencyReader();
 
   @override
   _LinkedDependencyImpl createObject(fb.BufferPointer bp) => new _LinkedDependencyImpl(bp);
 }
 
 class _LinkedDependencyImpl extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
   final fb.BufferPointer _bp;
 
   _LinkedDependencyImpl(this._bp);
 
+  List<String> _parts;
   String _uri;
-  List<String> _parts;
+
+  @override
+  List<String> get parts {
+    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    return _parts;
+  }
 
   @override
   String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _uri ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _uri;
   }
-
-  @override
-  List<String> get parts {
-    _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
-    return _parts;
-  }
 }
 
 abstract class _LinkedDependencyMixin implements idl.LinkedDependency {
   @override
   Map<String, Object> toMap() => {
+    "parts": parts,
     "uri": uri,
-    "parts": parts,
   };
 }
 
 class LinkedExportNameBuilder extends Object with _LinkedExportNameMixin implements idl.LinkedExportName {
   bool _finished = false;
 
+  int _dependency;
+  idl.ReferenceKind _kind;
   String _name;
-  int _dependency;
   int _unit;
-  idl.ReferenceKind _kind;
-
-  @override
-  String get name => _name ??= '';
-
-  /**
-   * Name of the exported entity.  For an exported setter, this name includes
-   * the trailing '='.
-   */
-  void set name(String _value) {
-    assert(!_finished);
-    _name = _value;
-  }
 
   @override
   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
+  idl.ReferenceKind get kind => _kind ??= idl.ReferenceKind.classOrEnum;
+
+  /**
+   * The kind of the entity being referred to.
+   */
+  void set kind(idl.ReferenceKind _value) {
+    assert(!_finished);
+    _kind = _value;
+  }
+
+  @override
+  String get name => _name ??= '';
+
+  /**
+   * Name of the exported entity.  For an exported setter, this name includes
+   * the trailing '='.
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _value;
+  }
+
+  @override
   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
-  idl.ReferenceKind get kind => _kind ??= idl.ReferenceKind.classOrEnum;
-
-  /**
-   * The kind of the entity being referred to.
-   */
-  void set kind(idl.ReferenceKind _value) {
-    assert(!_finished);
-    _kind = _value;
-  }
-
-  LinkedExportNameBuilder({String name, int dependency, int unit, idl.ReferenceKind kind})
-    : _name = name,
-      _dependency = dependency,
-      _unit = unit,
-      _kind = kind;
+  LinkedExportNameBuilder({int dependency, idl.ReferenceKind kind, String name, int unit})
+    : _dependency = dependency,
+      _kind = kind,
+      _name = name,
+      _unit = unit;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
+    if (_dependency != null && _dependency != 0) {
+      fbBuilder.addUint32(0, _dependency);
+    }
+    if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
+      fbBuilder.addUint32(1, _kind.index);
+    }
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
-    }
-    if (_dependency != null && _dependency != 0) {
-      fbBuilder.addUint32(1, _dependency);
+      fbBuilder.addOffset(2, offset_name);
     }
     if (_unit != null && _unit != 0) {
-      fbBuilder.addUint32(2, _unit);
-    }
-    if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
-      fbBuilder.addUint32(3, _kind.index);
+      fbBuilder.addUint32(3, _unit);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedExportNameReader extends fb.TableReader<_LinkedExportNameImpl> {
   const _LinkedExportNameReader();
 
   @override
   _LinkedExportNameImpl createObject(fb.BufferPointer bp) => new _LinkedExportNameImpl(bp);
 }
 
 class _LinkedExportNameImpl extends Object with _LinkedExportNameMixin implements idl.LinkedExportName {
   final fb.BufferPointer _bp;
 
   _LinkedExportNameImpl(this._bp);
 
+  int _dependency;
+  idl.ReferenceKind _kind;
   String _name;
-  int _dependency;
   int _unit;
-  idl.ReferenceKind _kind;
+
+  @override
+  int get dependency {
+    _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    return _dependency;
+  }
+
+  @override
+  idl.ReferenceKind get kind {
+    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, idl.ReferenceKind.classOrEnum);
+    return _kind;
+  }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
     return _name;
   }
 
   @override
-  int get dependency {
-    _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _dependency;
-  }
-
-  @override
   int get unit {
-    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _unit;
   }
-
-  @override
-  idl.ReferenceKind get kind {
-    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 3, idl.ReferenceKind.classOrEnum);
-    return _kind;
-  }
 }
 
 abstract class _LinkedExportNameMixin implements idl.LinkedExportName {
   @override
   Map<String, Object> toMap() => {
+    "dependency": dependency,
+    "kind": kind,
     "name": name,
-    "dependency": dependency,
     "unit": unit,
-    "kind": kind,
   };
 }
 
 class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements idl.LinkedLibrary {
   bool _finished = false;
 
+  List<LinkedDependencyBuilder> _dependencies;
+  List<LinkedExportNameBuilder> _exportNames;
+  List<int> _importDependencies;
+  int _numPrelinkedDependencies;
   List<LinkedUnitBuilder> _units;
-  List<LinkedDependencyBuilder> _dependencies;
-  List<int> _importDependencies;
-  List<LinkedExportNameBuilder> _exportNames;
-  int _numPrelinkedDependencies;
-
-  @override
-  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<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` and
    * `void`).  This is followed by elements representing "prelinked"
    * dependencies (direct imports and the transitive closure of exports).
    * After the prelinked dependencies are elements representing "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 ??= <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<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
+  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
   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;
   }
 
-  LinkedLibraryBuilder({List<LinkedUnitBuilder> units, List<LinkedDependencyBuilder> dependencies, List<int> importDependencies, List<LinkedExportNameBuilder> exportNames, int numPrelinkedDependencies})
-    : _units = units,
-      _dependencies = dependencies,
+  @override
+  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;
+  }
+
+  LinkedLibraryBuilder({List<LinkedDependencyBuilder> dependencies, List<LinkedExportNameBuilder> exportNames, List<int> importDependencies, int numPrelinkedDependencies, List<LinkedUnitBuilder> units})
+    : _dependencies = dependencies,
+      _exportNames = exportNames,
       _importDependencies = importDependencies,
-      _exportNames = exportNames,
-      _numPrelinkedDependencies = numPrelinkedDependencies;
+      _numPrelinkedDependencies = numPrelinkedDependencies,
+      _units = units;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_dependencies;
+    fb.Offset offset_exportNames;
+    fb.Offset offset_importDependencies;
     fb.Offset offset_units;
-    fb.Offset offset_dependencies;
-    fb.Offset offset_importDependencies;
-    fb.Offset offset_exportNames;
-    if (!(_units == null || _units.isEmpty)) {
-      offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
-    }
     if (!(_dependencies == null || _dependencies.isEmpty)) {
       offset_dependencies = fbBuilder.writeList(_dependencies.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_exportNames == null || _exportNames.isEmpty)) {
+      offset_exportNames = fbBuilder.writeList(_exportNames.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_importDependencies == null || _importDependencies.isEmpty)) {
       offset_importDependencies = fbBuilder.writeListUint32(_importDependencies);
     }
-    if (!(_exportNames == null || _exportNames.isEmpty)) {
-      offset_exportNames = fbBuilder.writeList(_exportNames.map((b) => b.finish(fbBuilder)).toList());
+    if (!(_units == null || _units.isEmpty)) {
+      offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
-    if (offset_units != null) {
-      fbBuilder.addOffset(0, offset_units);
+    if (offset_dependencies != null) {
+      fbBuilder.addOffset(0, offset_dependencies);
     }
-    if (offset_dependencies != null) {
-      fbBuilder.addOffset(1, offset_dependencies);
+    if (offset_exportNames != null) {
+      fbBuilder.addOffset(1, offset_exportNames);
     }
     if (offset_importDependencies != null) {
       fbBuilder.addOffset(2, offset_importDependencies);
     }
-    if (offset_exportNames != null) {
-      fbBuilder.addOffset(3, offset_exportNames);
+    if (_numPrelinkedDependencies != null && _numPrelinkedDependencies != 0) {
+      fbBuilder.addUint32(3, _numPrelinkedDependencies);
     }
-    if (_numPrelinkedDependencies != null && _numPrelinkedDependencies != 0) {
-      fbBuilder.addUint32(4, _numPrelinkedDependencies);
+    if (offset_units != null) {
+      fbBuilder.addOffset(4, offset_units);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.LinkedLibrary readLinkedLibrary(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _LinkedLibraryReader().read(rootRef);
 }
 
 class _LinkedLibraryReader extends fb.TableReader<_LinkedLibraryImpl> {
   const _LinkedLibraryReader();
 
   @override
   _LinkedLibraryImpl createObject(fb.BufferPointer bp) => new _LinkedLibraryImpl(bp);
 }
 
 class _LinkedLibraryImpl extends Object with _LinkedLibraryMixin implements idl.LinkedLibrary {
   final fb.BufferPointer _bp;
 
   _LinkedLibraryImpl(this._bp);
 
+  List<idl.LinkedDependency> _dependencies;
+  List<idl.LinkedExportName> _exportNames;
+  List<int> _importDependencies;
+  int _numPrelinkedDependencies;
   List<idl.LinkedUnit> _units;
-  List<idl.LinkedDependency> _dependencies;
-  List<int> _importDependencies;
-  List<idl.LinkedExportName> _exportNames;
-  int _numPrelinkedDependencies;
-
-  @override
-  List<idl.LinkedUnit> get units {
-    _units ??= const fb.ListReader<idl.LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 0, const <idl.LinkedUnit>[]);
-    return _units;
-  }
 
   @override
   List<idl.LinkedDependency> get dependencies {
-    _dependencies ??= const fb.ListReader<idl.LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 1, const <idl.LinkedDependency>[]);
+    _dependencies ??= const fb.ListReader<idl.LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 0, const <idl.LinkedDependency>[]);
     return _dependencies;
   }
 
   @override
+  List<idl.LinkedExportName> get exportNames {
+    _exportNames ??= const fb.ListReader<idl.LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 1, const <idl.LinkedExportName>[]);
+    return _exportNames;
+  }
+
+  @override
   List<int> get importDependencies {
     _importDependencies ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 2, const <int>[]);
     return _importDependencies;
   }
 
   @override
-  List<idl.LinkedExportName> get exportNames {
-    _exportNames ??= const fb.ListReader<idl.LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 3, const <idl.LinkedExportName>[]);
-    return _exportNames;
-  }
-
-  @override
   int get numPrelinkedDependencies {
-    _numPrelinkedDependencies ??= const fb.Uint32Reader().vTableGet(_bp, 4, 0);
+    _numPrelinkedDependencies ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _numPrelinkedDependencies;
   }
+
+  @override
+  List<idl.LinkedUnit> get units {
+    _units ??= const fb.ListReader<idl.LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 4, const <idl.LinkedUnit>[]);
+    return _units;
+  }
 }
 
 abstract class _LinkedLibraryMixin implements idl.LinkedLibrary {
   @override
   Map<String, Object> toMap() => {
+    "dependencies": dependencies,
+    "exportNames": exportNames,
+    "importDependencies": importDependencies,
+    "numPrelinkedDependencies": numPrelinkedDependencies,
     "units": units,
-    "dependencies": dependencies,
-    "importDependencies": importDependencies,
-    "exportNames": exportNames,
-    "numPrelinkedDependencies": numPrelinkedDependencies,
   };
 }
 
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements idl.LinkedReference {
   bool _finished = false;
 
+  int _containingReference;
   int _dependency;
   idl.ReferenceKind _kind;
+  String _name;
+  int _numTypeParameters;
   int _unit;
-  int _numTypeParameters;
-  String _name;
-  int _containingReference;
+
+  @override
+  int get containingReference => _containingReference ??= 0;
+
+  /**
+   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
+   * and the entity being referred to is contained within another entity, index
+   * of the containing entity.  This behaves similarly to
+   * [UnlinkedReference.prefixReference], however it is only used for class
+   * members, not for prefixed imports.
+   *
+   * Containing references must always point backward; that is, for all i, if
+   * LinkedUnit.references[i].containingReference != 0, then
+   * LinkedUnit.references[i].containingReference < i.
+   */
+  void set containingReference(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _containingReference = _value;
+  }
 
   @override
   int get dependency => _dependency ??= 0;
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    *
    * Zero if this entity is contained within another entity (e.g. a class
    * member), or if [kind] is [ReferenceKind.prefix].
@@ skipping 10 matching lines @@
   /**
    * The kind of the entity being referred to.  For the pseudo-types `dynamic`
    * and `void`, the kind is [ReferenceKind.classOrEnum].
    */
   void set kind(idl.ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  int get unit => _unit ??= 0;
+  String get name => _name ??= '';
 
   /**
-   * 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.
-   *
-   * Zero if this entity is contained within another entity (e.g. a class
-   * member).
+   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
+   * name of the entity being referred to.  For the pseudo-type `dynamic`, the
+   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
-  void set unit(int _value) {
+  void set name(String _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _unit = _value;
+    _name = _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);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
   @override
-  String get name => _name ??= '';
+  int get unit => _unit ??= 0;
 
   /**
-   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
-   * name of the entity being referred to.  For the pseudo-type `dynamic`, the
-   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
+   * 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.
+   *
+   * Zero if this entity is contained within another entity (e.g. a class
+   * member).
    */
-  void set name(String _value) {
+  void set unit(int _value) {
     assert(!_finished);
-    _name = _value;
+    assert(_value == null || _value >= 0);
+    _unit = _value;
   }
 
-  @override
-  int get containingReference => _containingReference ??= 0;
-
-  /**
-   * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
-   * and the entity being referred to is contained within another entity, index
-   * of the containing entity.  This behaves similarly to
-   * [UnlinkedReference.prefixReference], however it is only used for class
-   * members, not for prefixed imports.
-   *
-   * Containing references must always point backward; that is, for all i, if
-   * LinkedUnit.references[i].containingReference != 0, then
-   * LinkedUnit.references[i].containingReference < i.
-   */
-  void set containingReference(int _value) {
-    assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _containingReference = _value;
-  }
-
-  LinkedReferenceBuilder({int dependency, idl.ReferenceKind kind, int unit, int numTypeParameters, String name, int containingReference})
-    : _dependency = dependency,
+  LinkedReferenceBuilder({int containingReference, int dependency, idl.ReferenceKind kind, String name, int numTypeParameters, int unit})
+    : _containingReference = containingReference,
+      _dependency = dependency,
       _kind = kind,
-      _unit = unit,
+      _name = name,
       _numTypeParameters = numTypeParameters,
-      _name = name,
-      _containingReference = containingReference;
+      _unit = unit;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
+    if (_containingReference != null && _containingReference != 0) {
+      fbBuilder.addUint32(0, _containingReference);
+    }
     if (_dependency != null && _dependency != 0) {
-      fbBuilder.addUint32(0, _dependency);
+      fbBuilder.addUint32(1, _dependency);
     }
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
-      fbBuilder.addUint32(1, _kind.index);
+      fbBuilder.addUint32(2, _kind.index);
+    }
+    if (offset_name != null) {
+      fbBuilder.addOffset(3, offset_name);
+    }
+    if (_numTypeParameters != null && _numTypeParameters != 0) {
+      fbBuilder.addUint32(4, _numTypeParameters);
     }
     if (_unit != null && _unit != 0) {
-      fbBuilder.addUint32(2, _unit);
-    }
-    if (_numTypeParameters != null && _numTypeParameters != 0) {
-      fbBuilder.addUint32(3, _numTypeParameters);
-    }
-    if (offset_name != null) {
-      fbBuilder.addOffset(4, offset_name);
-    }
-    if (_containingReference != null && _containingReference != 0) {
-      fbBuilder.addUint32(5, _containingReference);
+      fbBuilder.addUint32(5, _unit);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedReferenceReader extends fb.TableReader<_LinkedReferenceImpl> {
   const _LinkedReferenceReader();
 
   @override
   _LinkedReferenceImpl createObject(fb.BufferPointer bp) => new _LinkedReferenceImpl(bp);
 }
 
 class _LinkedReferenceImpl extends Object with _LinkedReferenceMixin implements idl.LinkedReference {
   final fb.BufferPointer _bp;
 
   _LinkedReferenceImpl(this._bp);
 
+  int _containingReference;
   int _dependency;
   idl.ReferenceKind _kind;
+  String _name;
+  int _numTypeParameters;
   int _unit;
-  int _numTypeParameters;
-  String _name;
-  int _containingReference;
+
+  @override
+  int get containingReference {
+    _containingReference ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    return _containingReference;
+  }
 
   @override
   int get dependency {
-    _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    _dependency ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _dependency;
   }
 
   @override
   idl.ReferenceKind get kind {
-    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, idl.ReferenceKind.classOrEnum);
+    _kind ??= const _ReferenceKindReader().vTableGet(_bp, 2, idl.ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
-  int get unit {
-    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
-    return _unit;
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 3, '');
+    return _name;
   }
 
   @override
   int get numTypeParameters {
-    _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 4, 0);
     return _numTypeParameters;
   }
 
   @override
-  String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 4, '');
-    return _name;
-  }
-
-  @override
-  int get containingReference {
-    _containingReference ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
-    return _containingReference;
+  int get unit {
+    _unit ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    return _unit;
   }
 }
 
 abstract class _LinkedReferenceMixin implements idl.LinkedReference {
   @override
   Map<String, Object> toMap() => {
+    "containingReference": containingReference,
     "dependency": dependency,
     "kind": kind,
+    "name": name,
+    "numTypeParameters": numTypeParameters,
     "unit": unit,
-    "numTypeParameters": numTypeParameters,
-    "name": name,
-    "containingReference": containingReference,
   };
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
   List<EntityRefBuilder> _types;
 
   @override
@@ skipping 82 matching lines @@
   @override
   Map<String, Object> toMap() => {
     "references": references,
     "types": types,
   };
 }
 
 class SdkBundleBuilder extends Object with _SdkBundleMixin implements idl.SdkBundle {
   bool _finished = false;
 
+  List<LinkedLibraryBuilder> _linkedLibraries;
   List<String> _linkedLibraryUris;
-  List<LinkedLibraryBuilder> _linkedLibraries;
+  List<UnlinkedUnitBuilder> _unlinkedUnits;
   List<String> _unlinkedUnitUris;
-  List<UnlinkedUnitBuilder> _unlinkedUnits;
-
-  @override
-  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<LinkedLibraryBuilder> get linkedLibraries => _linkedLibraries ??= <LinkedLibraryBuilder>[];
 
   /**
    * Linked libraries.
    */
   void set linkedLibraries(List<LinkedLibraryBuilder> _value) {
     assert(!_finished);
     _linkedLibraries = _value;
   }
 
   @override
-  List<String> get unlinkedUnitUris => _unlinkedUnitUris ??= <String>[];
+  List<String> get linkedLibraryUris => _linkedLibraryUris ??= <String>[];
 
   /**
-   * The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
+   * The list of URIs of items in [linkedLibraries], e.g. `dart:core`.
    */
-  void set unlinkedUnitUris(List<String> _value) {
+  void set linkedLibraryUris(List<String> _value) {
     assert(!_finished);
-    _unlinkedUnitUris = _value;
+    _linkedLibraryUris = _value;
   }
 
   @override
   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})
-    : _linkedLibraryUris = linkedLibraryUris,
-      _linkedLibraries = linkedLibraries,
-      _unlinkedUnitUris = unlinkedUnitUris,
-      _unlinkedUnits = unlinkedUnits;
+  @override
+  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;
+  }
+
+  SdkBundleBuilder({List<LinkedLibraryBuilder> linkedLibraries, List<String> linkedLibraryUris, List<UnlinkedUnitBuilder> unlinkedUnits, List<String> unlinkedUnitUris})
+    : _linkedLibraries = linkedLibraries,
+      _linkedLibraryUris = linkedLibraryUris,
+      _unlinkedUnits = unlinkedUnits,
+      _unlinkedUnitUris = unlinkedUnitUris;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_linkedLibraries;
     fb.Offset offset_linkedLibraryUris;
-    fb.Offset offset_linkedLibraries;
+    fb.Offset offset_unlinkedUnits;
     fb.Offset offset_unlinkedUnitUris;
-    fb.Offset offset_unlinkedUnits;
+    if (!(_linkedLibraries == null || _linkedLibraries.isEmpty)) {
+      offset_linkedLibraries = fbBuilder.writeList(_linkedLibraries.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_linkedLibraryUris == null || _linkedLibraryUris.isEmpty)) {
       offset_linkedLibraryUris = fbBuilder.writeList(_linkedLibraryUris.map((b) => fbBuilder.writeString(b)).toList());
     }
-    if (!(_linkedLibraries == null || _linkedLibraries.isEmpty)) {
-      offset_linkedLibraries = fbBuilder.writeList(_linkedLibraries.map((b) => b.finish(fbBuilder)).toList());
+    if (!(_unlinkedUnits == null || _unlinkedUnits.isEmpty)) {
+      offset_unlinkedUnits = fbBuilder.writeList(_unlinkedUnits.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_unlinkedUnitUris == null || _unlinkedUnitUris.isEmpty)) {
       offset_unlinkedUnitUris = fbBuilder.writeList(_unlinkedUnitUris.map((b) => fbBuilder.writeString(b)).toList());
     }
-    if (!(_unlinkedUnits == null || _unlinkedUnits.isEmpty)) {
-      offset_unlinkedUnits = fbBuilder.writeList(_unlinkedUnits.map((b) => b.finish(fbBuilder)).toList());
+    fbBuilder.startTable();
+    if (offset_linkedLibraries != null) {
+      fbBuilder.addOffset(0, offset_linkedLibraries);
     }
-    fbBuilder.startTable();
     if (offset_linkedLibraryUris != null) {
-      fbBuilder.addOffset(0, offset_linkedLibraryUris);
+      fbBuilder.addOffset(1, offset_linkedLibraryUris);
     }
-    if (offset_linkedLibraries != null) {
-      fbBuilder.addOffset(1, offset_linkedLibraries);
+    if (offset_unlinkedUnits != null) {
+      fbBuilder.addOffset(2, offset_unlinkedUnits);
     }
     if (offset_unlinkedUnitUris != null) {
-      fbBuilder.addOffset(2, offset_unlinkedUnitUris);
-    }
-    if (offset_unlinkedUnits != null) {
-      fbBuilder.addOffset(3, offset_unlinkedUnits);
+      fbBuilder.addOffset(3, offset_unlinkedUnitUris);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.SdkBundle readSdkBundle(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _SdkBundleReader().read(rootRef);
 }
 
 class _SdkBundleReader extends fb.TableReader<_SdkBundleImpl> {
   const _SdkBundleReader();
 
   @override
   _SdkBundleImpl createObject(fb.BufferPointer bp) => new _SdkBundleImpl(bp);
 }
 
 class _SdkBundleImpl extends Object with _SdkBundleMixin implements idl.SdkBundle {
   final fb.BufferPointer _bp;
 
   _SdkBundleImpl(this._bp);
 
+  List<idl.LinkedLibrary> _linkedLibraries;
   List<String> _linkedLibraryUris;
-  List<idl.LinkedLibrary> _linkedLibraries;
+  List<idl.UnlinkedUnit> _unlinkedUnits;
   List<String> _unlinkedUnitUris;
-  List<idl.UnlinkedUnit> _unlinkedUnits;
+
+  @override
+  List<idl.LinkedLibrary> get linkedLibraries {
+    _linkedLibraries ??= const fb.ListReader<idl.LinkedLibrary>(const _LinkedLibraryReader()).vTableGet(_bp, 0, const <idl.LinkedLibrary>[]);
+    return _linkedLibraries;
+  }
 
   @override
   List<String> get linkedLibraryUris {
-    _linkedLibraryUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    _linkedLibraryUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _linkedLibraryUris;
   }
 
   @override
-  List<idl.LinkedLibrary> get linkedLibraries {
-    _linkedLibraries ??= const fb.ListReader<idl.LinkedLibrary>(const _LinkedLibraryReader()).vTableGet(_bp, 1, const <idl.LinkedLibrary>[]);
-    return _linkedLibraries;
+  List<idl.UnlinkedUnit> get unlinkedUnits {
+    _unlinkedUnits ??= const fb.ListReader<idl.UnlinkedUnit>(const _UnlinkedUnitReader()).vTableGet(_bp, 2, const <idl.UnlinkedUnit>[]);
+    return _unlinkedUnits;
   }
 
   @override
   List<String> get unlinkedUnitUris {
-    _unlinkedUnitUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
+    _unlinkedUnitUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 3, const <String>[]);
     return _unlinkedUnitUris;
   }
-
-  @override
-  List<idl.UnlinkedUnit> get unlinkedUnits {
-    _unlinkedUnits ??= const fb.ListReader<idl.UnlinkedUnit>(const _UnlinkedUnitReader()).vTableGet(_bp, 3, const <idl.UnlinkedUnit>[]);
-    return _unlinkedUnits;
-  }
 }
 
 abstract class _SdkBundleMixin implements idl.SdkBundle {
   @override
   Map<String, Object> toMap() => {
+    "linkedLibraries": linkedLibraries,
     "linkedLibraryUris": linkedLibraryUris,
-    "linkedLibraries": linkedLibraries,
+    "unlinkedUnits": unlinkedUnits,
     "unlinkedUnitUris": unlinkedUnitUris,
-    "unlinkedUnits": unlinkedUnits,
   };
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  UnlinkedDocumentationCommentBuilder _documentationComment;
+  List<UnlinkedExecutableBuilder> _executables;
+  List<UnlinkedVariableBuilder> _fields;
+  bool _hasNoSupertype;
+  List<EntityRefBuilder> _interfaces;
+  bool _isAbstract;
+  bool _isMixinApplication;
+  List<EntityRefBuilder> _mixins;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
-  List<UnlinkedConstBuilder> _annotations;
+  EntityRefBuilder _supertype;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  EntityRefBuilder _supertype;
-  List<EntityRefBuilder> _mixins;
-  List<EntityRefBuilder> _interfaces;
-  List<UnlinkedVariableBuilder> _fields;
-  List<UnlinkedExecutableBuilder> _executables;
-  bool _isAbstract;
-  bool _isMixinApplication;
-  bool _hasNoSupertype;
+
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this class.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
+  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<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
+  List<UnlinkedVariableBuilder> get fields => _fields ??= <UnlinkedVariableBuilder>[];
+
+  /**
+   * Field declarations contained in the class.
+   */
+  void set fields(List<UnlinkedVariableBuilder> _value) {
+    assert(!_finished);
+    _fields = _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;
+  }
+
+  @override
+  List<EntityRefBuilder> get interfaces => _interfaces ??= <EntityRefBuilder>[];
+
+  /**
+   * Interfaces appearing in an `implements` clause, if any.
+   */
+  void set interfaces(List<EntityRefBuilder> _value) {
+    assert(!_finished);
+    _interfaces = _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
+  List<EntityRefBuilder> get mixins => _mixins ??= <EntityRefBuilder>[];
+
+  /**
+   * Mixins appearing in a `with` clause, if any.
+   */
+  void set mixins(List<EntityRefBuilder> _value) {
+    assert(!_finished);
+    _mixins = _value;
+  }
 
   @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);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
-  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<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * Annotations for this class.
-   */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _annotations = _value;
-  }
-
-  @override
-  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
-
-  /**
-   * Type parameters of the class, if any.
-   */
-  void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
-    assert(!_finished);
-    _typeParameters = _value;
-  }
-
-  @override
   EntityRefBuilder 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(EntityRefBuilder _value) {
     assert(!_finished);
     _supertype = _value;
   }
 
   @override
-  List<EntityRefBuilder> get mixins => _mixins ??= <EntityRefBuilder>[];
-
-  /**
-   * Mixins appearing in a `with` clause, if any.
-   */
-  void set mixins(List<EntityRefBuilder> _value) {
-    assert(!_finished);
-    _mixins = _value;
-  }
-
-  @override
-  List<EntityRefBuilder> get interfaces => _interfaces ??= <EntityRefBuilder>[];
-
-  /**
-   * Interfaces appearing in an `implements` clause, if any.
-   */
-  void set interfaces(List<EntityRefBuilder> _value) {
-    assert(!_finished);
-    _interfaces = _value;
-  }
-
-  @override
-  List<UnlinkedVariableBuilder> get fields => _fields ??= <UnlinkedVariableBuilder>[];
-
-  /**
-   * Field declarations contained in the class.
-   */
-  void set fields(List<UnlinkedVariableBuilder> _value) {
-    assert(!_finished);
-    _fields = _value;
-  }
-
-  @override
-  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;
-
-  /**
-   * 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;
-  }
-
-  UnlinkedClassBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder supertype, List<EntityRefBuilder> mixins, List<EntityRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype})
-    : _name = name,
-      _nameOffset = nameOffset,
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
+
+  /**
+   * Type parameters of the class, if any.
+   */
+  void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
+    assert(!_finished);
+    _typeParameters = _value;
+  }
+
+  UnlinkedClassBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedExecutableBuilder> executables, List<UnlinkedVariableBuilder> fields, bool hasNoSupertype, List<EntityRefBuilder> interfaces, bool isAbstract, bool isMixinApplication, List<EntityRefBuilder> mixins, String name, int nameOffset, EntityRefBuilder supertype, List<UnlinkedTypeParamBuilder> typeParameters})
+    : _annotations = annotations,
       _documentationComment = documentationComment,
-      _annotations = annotations,
-      _typeParameters = typeParameters,
-      _supertype = supertype,
-      _mixins = mixins,
+      _executables = executables,
+      _fields = fields,
+      _hasNoSupertype = hasNoSupertype,
       _interfaces = interfaces,
-      _fields = fields,
-      _executables = executables,
       _isAbstract = isAbstract,
       _isMixinApplication = isMixinApplication,
-      _hasNoSupertype = hasNoSupertype;
+      _mixins = mixins,
+      _name = name,
+      _nameOffset = nameOffset,
+      _supertype = supertype,
+      _typeParameters = typeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_documentationComment;
+    fb.Offset offset_executables;
+    fb.Offset offset_fields;
+    fb.Offset offset_interfaces;
+    fb.Offset offset_mixins;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
-    fb.Offset offset_annotations;
+    fb.Offset offset_supertype;
     fb.Offset offset_typeParameters;
-    fb.Offset offset_supertype;
-    fb.Offset offset_mixins;
-    fb.Offset offset_interfaces;
-    fb.Offset offset_fields;
-    fb.Offset offset_executables;
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_documentationComment != null) {
+      offset_documentationComment = _documentationComment.finish(fbBuilder);
+    }
+    if (!(_executables == null || _executables.isEmpty)) {
+      offset_executables = fbBuilder.writeList(_executables.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (!(_fields == null || _fields.isEmpty)) {
+      offset_fields = fbBuilder.writeList(_fields.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (!(_interfaces == null || _interfaces.isEmpty)) {
+      offset_interfaces = fbBuilder.writeList(_interfaces.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (!(_mixins == null || _mixins.isEmpty)) {
+      offset_mixins = fbBuilder.writeList(_mixins.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
-    if (_documentationComment != null) {
-      offset_documentationComment = _documentationComment.finish(fbBuilder);
-    }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (_supertype != null) {
+      offset_supertype = _supertype.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
-    if (_supertype != null) {
-      offset_supertype = _supertype.finish(fbBuilder);
-    }
-    if (!(_mixins == null || _mixins.isEmpty)) {
-      offset_mixins = fbBuilder.writeList(_mixins.map((b) => b.finish(fbBuilder)).toList());
-    }
-    if (!(_interfaces == null || _interfaces.isEmpty)) {
-      offset_interfaces = fbBuilder.writeList(_interfaces.map((b) => b.finish(fbBuilder)).toList());
-    }
-    if (!(_fields == null || _fields.isEmpty)) {
-      offset_fields = fbBuilder.writeList(_fields.map((b) => b.finish(fbBuilder)).toList());
-    }
-    if (!(_executables == null || _executables.isEmpty)) {
-      offset_executables = fbBuilder.writeList(_executables.map((b) => b.finish(fbBuilder)).toList());
-    }
     fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
+    }
+    if (offset_documentationComment != null) {
+      fbBuilder.addOffset(1, offset_documentationComment);
+    }
+    if (offset_executables != null) {
+      fbBuilder.addOffset(2, offset_executables);
+    }
+    if (offset_fields != null) {
+      fbBuilder.addOffset(3, offset_fields);
+    }
+    if (_hasNoSupertype == true) {
+      fbBuilder.addBool(4, true);
+    }
+    if (offset_interfaces != null) {
+      fbBuilder.addOffset(5, offset_interfaces);
+    }
+    if (_isAbstract == true) {
+      fbBuilder.addBool(6, true);
+    }
+    if (_isMixinApplication == true) {
+      fbBuilder.addBool(7, true);
+    }
+    if (offset_mixins != null) {
+      fbBuilder.addOffset(8, offset_mixins);
+    }
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+      fbBuilder.addOffset(9, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
-    }
-    if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
-    }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
+      fbBuilder.addUint32(10, _nameOffset);
+    }
+    if (offset_supertype != null) {
+      fbBuilder.addOffset(11, offset_supertype);
     }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(4, offset_typeParameters);
-    }
-    if (offset_supertype != null) {
-      fbBuilder.addOffset(5, offset_supertype);
-    }
-    if (offset_mixins != null) {
-      fbBuilder.addOffset(6, offset_mixins);
-    }
-    if (offset_interfaces != null) {
-      fbBuilder.addOffset(7, offset_interfaces);
-    }
-    if (offset_fields != null) {
-      fbBuilder.addOffset(8, offset_fields);
-    }
-    if (offset_executables != null) {
-      fbBuilder.addOffset(9, offset_executables);
-    }
-    if (_isAbstract == true) {
-      fbBuilder.addBool(10, true);
-    }
-    if (_isMixinApplication == true) {
-      fbBuilder.addBool(11, true);
-    }
-    if (_hasNoSupertype == true) {
-      fbBuilder.addBool(12, true);
+      fbBuilder.addOffset(12, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedClassReader extends fb.TableReader<_UnlinkedClassImpl> {
   const _UnlinkedClassReader();
 
   @override
   _UnlinkedClassImpl createObject(fb.BufferPointer bp) => new _UnlinkedClassImpl(bp);
 }
 
 class _UnlinkedClassImpl extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
   final fb.BufferPointer _bp;
 
   _UnlinkedClassImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.UnlinkedDocumentationComment _documentationComment;
+  List<idl.UnlinkedExecutable> _executables;
+  List<idl.UnlinkedVariable> _fields;
+  bool _hasNoSupertype;
+  List<idl.EntityRef> _interfaces;
+  bool _isAbstract;
+  bool _isMixinApplication;
+  List<idl.EntityRef> _mixins;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
-  List<idl.UnlinkedConst> _annotations;
+  idl.EntityRef _supertype;
   List<idl.UnlinkedTypeParam> _typeParameters;
-  idl.EntityRef _supertype;
-  List<idl.EntityRef> _mixins;
-  List<idl.EntityRef> _interfaces;
-  List<idl.UnlinkedVariable> _fields;
-  List<idl.UnlinkedExecutable> _executables;
-  bool _isAbstract;
-  bool _isMixinApplication;
-  bool _hasNoSupertype;
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
+  idl.UnlinkedDocumentationComment get documentationComment {
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    return _documentationComment;
+  }
+
+  @override
+  List<idl.UnlinkedExecutable> get executables {
+    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 2, const <idl.UnlinkedExecutable>[]);
+    return _executables;
+  }
+
+  @override
+  List<idl.UnlinkedVariable> get fields {
+    _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 3, const <idl.UnlinkedVariable>[]);
+    return _fields;
+  }
+
+  @override
+  bool get hasNoSupertype {
+    _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    return _hasNoSupertype;
+  }
+
+  @override
+  List<idl.EntityRef> get interfaces {
+    _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 5, const <idl.EntityRef>[]);
+    return _interfaces;
+  }
+
+  @override
+  bool get isAbstract {
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    return _isAbstract;
+  }
+
+  @override
+  bool get isMixinApplication {
+    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    return _isMixinApplication;
+  }
+
+  @override
+  List<idl.EntityRef> get mixins {
+    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 8, const <idl.EntityRef>[]);
+    return _mixins;
+  }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 9, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 10, 0);
     return _nameOffset;
   }
 
   @override
-  idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
-    return _documentationComment;
-  }
-
-  @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
+  idl.EntityRef get supertype {
+    _supertype ??= const _EntityRefReader().vTableGet(_bp, 11, null);
+    return _supertype;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 12, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
-
-  @override
-  idl.EntityRef get supertype {
-    _supertype ??= const _EntityRefReader().vTableGet(_bp, 5, null);
-    return _supertype;
-  }
-
-  @override
-  List<idl.EntityRef> get mixins {
-    _mixins ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 6, const <idl.EntityRef>[]);
-    return _mixins;
-  }
-
-  @override
-  List<idl.EntityRef> get interfaces {
-    _interfaces ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 7, const <idl.EntityRef>[]);
-    return _interfaces;
-  }
-
-  @override
-  List<idl.UnlinkedVariable> get fields {
-    _fields ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 8, const <idl.UnlinkedVariable>[]);
-    return _fields;
-  }
-
-  @override
-  List<idl.UnlinkedExecutable> get executables {
-    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 9, const <idl.UnlinkedExecutable>[]);
-    return _executables;
-  }
-
-  @override
-  bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 10, false);
-    return _isAbstract;
-  }
-
-  @override
-  bool get isMixinApplication {
-    _isMixinApplication ??= const fb.BoolReader().vTableGet(_bp, 11, false);
-    return _isMixinApplication;
-  }
-
-  @override
-  bool get hasNoSupertype {
-    _hasNoSupertype ??= const fb.BoolReader().vTableGet(_bp, 12, false);
-    return _hasNoSupertype;
-  }
 }
 
 abstract class _UnlinkedClassMixin implements idl.UnlinkedClass {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "documentationComment": documentationComment,
+    "executables": executables,
+    "fields": fields,
+    "hasNoSupertype": hasNoSupertype,
+    "interfaces": interfaces,
+    "isAbstract": isAbstract,
+    "isMixinApplication": isMixinApplication,
+    "mixins": mixins,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "annotations": annotations,
+    "supertype": supertype,
     "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 idl.UnlinkedCombinator {
   bool _finished = false;
 
+  List<String> _hides;
   List<String> _shows;
-  List<String> _hides;
+
+  @override
+  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;
+  }
 
   @override
   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 ??= <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})
-    : _shows = shows,
-      _hides = hides;
+  UnlinkedCombinatorBuilder({List<String> hides, List<String> shows})
+    : _hides = hides,
+      _shows = shows;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_hides;
     fb.Offset offset_shows;
-    fb.Offset offset_hides;
+    if (!(_hides == null || _hides.isEmpty)) {
+      offset_hides = fbBuilder.writeList(_hides.map((b) => fbBuilder.writeString(b)).toList());
+    }
     if (!(_shows == null || _shows.isEmpty)) {
       offset_shows = fbBuilder.writeList(_shows.map((b) => fbBuilder.writeString(b)).toList());
     }
-    if (!(_hides == null || _hides.isEmpty)) {
-      offset_hides = fbBuilder.writeList(_hides.map((b) => fbBuilder.writeString(b)).toList());
+    fbBuilder.startTable();
+    if (offset_hides != null) {
+      fbBuilder.addOffset(0, offset_hides);
     }
-    fbBuilder.startTable();
     if (offset_shows != null) {
-      fbBuilder.addOffset(0, offset_shows);
-    }
-    if (offset_hides != null) {
-      fbBuilder.addOffset(1, offset_hides);
+      fbBuilder.addOffset(1, offset_shows);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedCombinatorReader extends fb.TableReader<_UnlinkedCombinatorImpl> {
   const _UnlinkedCombinatorReader();
 
   @override
   _UnlinkedCombinatorImpl createObject(fb.BufferPointer bp) => new _UnlinkedCombinatorImpl(bp);
 }
 
 class _UnlinkedCombinatorImpl extends Object with _UnlinkedCombinatorMixin implements idl.UnlinkedCombinator {
   final fb.BufferPointer _bp;
 
   _UnlinkedCombinatorImpl(this._bp);
 
+  List<String> _hides;
   List<String> _shows;
-  List<String> _hides;
+
+  @override
+  List<String> get hides {
+    _hides ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    return _hides;
+  }
 
   @override
   List<String> get shows {
-    _shows ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    _shows ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _shows;
   }
-
-  @override
-  List<String> get hides {
-    _hides ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
-    return _hides;
-  }
 }
 
 abstract class _UnlinkedCombinatorMixin implements idl.UnlinkedCombinator {
   @override
   Map<String, Object> toMap() => {
+    "hides": hides,
     "shows": shows,
-    "hides": hides,
   };
 }
 
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   bool _finished = false;
 
+  List<double> _doubles;
+  List<int> _ints;
   bool _isInvalid;
   List<idl.UnlinkedConstOperation> _operations;
-  List<int> _ints;
-  List<double> _doubles;
+  List<EntityRefBuilder> _references;
   List<String> _strings;
-  List<EntityRefBuilder> _references;
 
   @override
-  bool get isInvalid => _isInvalid ??= false;
+  List<double> get doubles => _doubles ??= <double>[];
 
   /**
-   * Indicates whether the expression is not a valid potentially constant
-   * expression.
+   * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
    */
-  void set isInvalid(bool _value) {
+  void set doubles(List<double> _value) {
     assert(!_finished);
-    _isInvalid = _value;
+    _doubles = _value;
   }
 
   @override
-  List<idl.UnlinkedConstOperation> get operations => _operations ??= <idl.UnlinkedConstOperation>[];
-
-  /**
-   * Sequence of operations to execute (starting with an empty stack) to form
-   * the constant value.
-   */
-  void set operations(List<idl.UnlinkedConstOperation> _value) {
-    assert(!_finished);
-    _operations = _value;
-  }
-
-  @override
   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 ??= <double>[];
+  bool get isInvalid => _isInvalid ??= false;
 
   /**
-   * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
+   * Indicates whether the expression is not a valid potentially constant
+   * expression.
    */
-  void set doubles(List<double> _value) {
+  void set isInvalid(bool _value) {
     assert(!_finished);
-    _doubles = _value;
+    _isInvalid = _value;
   }
 
   @override
-  List<String> get strings => _strings ??= <String>[];
+  List<idl.UnlinkedConstOperation> get operations => _operations ??= <idl.UnlinkedConstOperation>[];
 
   /**
-   * Sequence of strings consumed by the operations `pushString` and
-   * `invokeConstructor`.
+   * Sequence of operations to execute (starting with an empty stack) to form
+   * the constant value.
    */
-  void set strings(List<String> _value) {
+  void set operations(List<idl.UnlinkedConstOperation> _value) {
     assert(!_finished);
-    _strings = _value;
+    _operations = _value;
   }
 
   @override
   List<EntityRefBuilder> get references => _references ??= <EntityRefBuilder>[];
 
   /**
    * 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<EntityRefBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
-  UnlinkedConstBuilder({bool isInvalid, List<idl.UnlinkedConstOperation> operations, List<int> ints, List<double> doubles, List<String> strings, List<EntityRefBuilder> references})
-    : _isInvalid = isInvalid,
+  @override
+  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;
+  }
+
+  UnlinkedConstBuilder({List<double> doubles, List<int> ints, bool isInvalid, List<idl.UnlinkedConstOperation> operations, List<EntityRefBuilder> references, List<String> strings})
+    : _doubles = doubles,
+      _ints = ints,
+      _isInvalid = isInvalid,
       _operations = operations,
-      _ints = ints,
-      _doubles = doubles,
-      _strings = strings,
-      _references = references;
+      _references = references,
+      _strings = strings;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_doubles;
+    fb.Offset offset_ints;
     fb.Offset offset_operations;
-    fb.Offset offset_ints;
-    fb.Offset offset_doubles;
+    fb.Offset offset_references;
     fb.Offset offset_strings;
-    fb.Offset offset_references;
-    if (!(_operations == null || _operations.isEmpty)) {
-      offset_operations = fbBuilder.writeListUint32(_operations.map((b) => b.index).toList());
+    if (!(_doubles == null || _doubles.isEmpty)) {
+      offset_doubles = fbBuilder.writeListFloat64(_doubles);
     }
     if (!(_ints == null || _ints.isEmpty)) {
       offset_ints = fbBuilder.writeListUint32(_ints);
     }
-    if (!(_doubles == null || _doubles.isEmpty)) {
-      offset_doubles = fbBuilder.writeListFloat64(_doubles);
+    if (!(_operations == null || _operations.isEmpty)) {
+      offset_operations = fbBuilder.writeListUint32(_operations.map((b) => b.index).toList());
+    }
+    if (!(_references == null || _references.isEmpty)) {
+      offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_strings == null || _strings.isEmpty)) {
       offset_strings = fbBuilder.writeList(_strings.map((b) => fbBuilder.writeString(b)).toList());
     }
-    if (!(_references == null || _references.isEmpty)) {
-      offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
+    fbBuilder.startTable();
+    if (offset_doubles != null) {
+      fbBuilder.addOffset(0, offset_doubles);
     }
-    fbBuilder.startTable();
+    if (offset_ints != null) {
+      fbBuilder.addOffset(1, offset_ints);
+    }
     if (_isInvalid == true) {
-      fbBuilder.addBool(0, true);
+      fbBuilder.addBool(2, true);
     }
     if (offset_operations != null) {
-      fbBuilder.addOffset(1, offset_operations);
+      fbBuilder.addOffset(3, offset_operations);
     }
-    if (offset_ints != null) {
-      fbBuilder.addOffset(2, offset_ints);
-    }
-    if (offset_doubles != null) {
-      fbBuilder.addOffset(3, offset_doubles);
+    if (offset_references != null) {
+      fbBuilder.addOffset(4, offset_references);
     }
     if (offset_strings != null) {
-      fbBuilder.addOffset(4, offset_strings);
-    }
-    if (offset_references != null) {
-      fbBuilder.addOffset(5, offset_references);
+      fbBuilder.addOffset(5, offset_strings);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstReader extends fb.TableReader<_UnlinkedConstImpl> {
   const _UnlinkedConstReader();
 
   @override
   _UnlinkedConstImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstImpl(bp);
 }
 
 class _UnlinkedConstImpl extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstImpl(this._bp);
 
+  List<double> _doubles;
+  List<int> _ints;
   bool _isInvalid;
   List<idl.UnlinkedConstOperation> _operations;
-  List<int> _ints;
-  List<double> _doubles;
+  List<idl.EntityRef> _references;
   List<String> _strings;
-  List<idl.EntityRef> _references;
+
+  @override
+  List<double> get doubles {
+    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 0, const <double>[]);
+    return _doubles;
+  }
+
+  @override
+  List<int> get ints {
+    _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 1, const <int>[]);
+    return _ints;
+  }
 
   @override
   bool get isInvalid {
-    _isInvalid ??= const fb.BoolReader().vTableGet(_bp, 0, false);
+    _isInvalid ??= const fb.BoolReader().vTableGet(_bp, 2, false);
     return _isInvalid;
   }
 
   @override
   List<idl.UnlinkedConstOperation> get operations {
-    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 1, const <idl.UnlinkedConstOperation>[]);
+    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 3, const <idl.UnlinkedConstOperation>[]);
     return _operations;
   }
 
   @override
-  List<int> get ints {
-    _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 2, const <int>[]);
-    return _ints;
-  }
-
-  @override
-  List<double> get doubles {
-    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 3, const <double>[]);
-    return _doubles;
+  List<idl.EntityRef> get references {
+    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <idl.EntityRef>[]);
+    return _references;
   }
 
   @override
   List<String> get strings {
-    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 4, const <String>[]);
+    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 5, const <String>[]);
     return _strings;
   }
-
-  @override
-  List<idl.EntityRef> get references {
-    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 5, const <idl.EntityRef>[]);
-    return _references;
-  }
 }
 
 abstract class _UnlinkedConstMixin implements idl.UnlinkedConst {
   @override
   Map<String, Object> toMap() => {
+    "doubles": doubles,
+    "ints": ints,
     "isInvalid": isInvalid,
     "operations": operations,
-    "ints": ints,
-    "doubles": doubles,
+    "references": references,
     "strings": strings,
-    "references": references,
   };
 }
 
 class UnlinkedConstructorInitializerBuilder extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _arguments;
+  UnlinkedConstBuilder _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
-  UnlinkedConstBuilder _expression;
-  List<UnlinkedConstBuilder> _arguments;
+
+  @override
+  List<UnlinkedConstBuilder> get arguments => _arguments ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
+   * invocation.  Otherwise empty.
+   */
+  void set arguments(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _arguments = _value;
+  }
+
+  @override
+  UnlinkedConstBuilder get expression => _expression;
+
+  /**
+   * If [kind] is `field`, the expression of the field initializer.
+   * Otherwise `null`.
+   */
+  void set expression(UnlinkedConstBuilder _value) {
+    assert(!_finished);
+    _expression = _value;
+  }
 
   @override
   idl.UnlinkedConstructorInitializerKind get kind => _kind ??= idl.UnlinkedConstructorInitializerKind.field;
 
   /**
    * The kind of the constructor initializer (field, redirect, super).
    */
   void set kind(idl.UnlinkedConstructorInitializerKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
    * If [kind] is `field`, the name of the field declared in the class.  If
    * [kind] is `thisInvocation`, the name of the constructor, declared in this
    * class, to redirect to.  If [kind] is `superInvocation`, the name of the
    * constructor, declared in the superclass, to invoke.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
-  @override
-  UnlinkedConstBuilder get expression => _expression;
-
-  /**
-   * If [kind] is `field`, the expression of the field initializer.
-   * Otherwise `null`.
-   */
-  void set expression(UnlinkedConstBuilder _value) {
-    assert(!_finished);
-    _expression = _value;
-  }
-
-  @override
-  List<UnlinkedConstBuilder> get arguments => _arguments ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
-   * invocation.  Otherwise empty.
-   */
-  void set arguments(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _arguments = _value;
-  }
-
-  UnlinkedConstructorInitializerBuilder({idl.UnlinkedConstructorInitializerKind kind, String name, UnlinkedConstBuilder expression, List<UnlinkedConstBuilder> arguments})
-    : _kind = kind,
-      _name = name,
+  UnlinkedConstructorInitializerBuilder({List<UnlinkedConstBuilder> arguments, UnlinkedConstBuilder expression, idl.UnlinkedConstructorInitializerKind kind, String name})
+    : _arguments = arguments,
       _expression = expression,
-      _arguments = arguments;
+      _kind = kind,
+      _name = name;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_arguments;
+    fb.Offset offset_expression;
     fb.Offset offset_name;
-    fb.Offset offset_expression;
-    fb.Offset offset_arguments;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
+    if (!(_arguments == null || _arguments.isEmpty)) {
+      offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_expression != null) {
       offset_expression = _expression.finish(fbBuilder);
     }
-    if (!(_arguments == null || _arguments.isEmpty)) {
-      offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
+    if (offset_arguments != null) {
+      fbBuilder.addOffset(0, offset_arguments);
+    }
+    if (offset_expression != null) {
+      fbBuilder.addOffset(1, offset_expression);
+    }
     if (_kind != null && _kind != idl.UnlinkedConstructorInitializerKind.field) {
-      fbBuilder.addUint32(0, _kind.index);
+      fbBuilder.addUint32(2, _kind.index);
     }
     if (offset_name != null) {
-      fbBuilder.addOffset(1, offset_name);
-    }
-    if (offset_expression != null) {
-      fbBuilder.addOffset(2, offset_expression);
-    }
-    if (offset_arguments != null) {
-      fbBuilder.addOffset(3, offset_arguments);
+      fbBuilder.addOffset(3, offset_name);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstructorInitializerReader extends fb.TableReader<_UnlinkedConstructorInitializerImpl> {
   const _UnlinkedConstructorInitializerReader();
 
   @override
   _UnlinkedConstructorInitializerImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstructorInitializerImpl(bp);
 }
 
 class _UnlinkedConstructorInitializerImpl extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstructorInitializerImpl(this._bp);
 
+  List<idl.UnlinkedConst> _arguments;
+  idl.UnlinkedConst _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
-  idl.UnlinkedConst _expression;
-  List<idl.UnlinkedConst> _arguments;
+
+  @override
+  List<idl.UnlinkedConst> get arguments {
+    _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _arguments;
+  }
+
+  @override
+  idl.UnlinkedConst get expression {
+    _expression ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
+    return _expression;
+  }
 
   @override
   idl.UnlinkedConstructorInitializerKind get kind {
-    _kind ??= const _UnlinkedConstructorInitializerKindReader().vTableGet(_bp, 0, idl.UnlinkedConstructorInitializerKind.field);
+    _kind ??= const _UnlinkedConstructorInitializerKindReader().vTableGet(_bp, 2, idl.UnlinkedConstructorInitializerKind.field);
     return _kind;
   }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 3, '');
     return _name;
   }
-
-  @override
-  idl.UnlinkedConst get expression {
-    _expression ??= const _UnlinkedConstReader().vTableGet(_bp, 2, null);
-    return _expression;
-  }
-
-  @override
-  List<idl.UnlinkedConst> get arguments {
-    _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _arguments;
-  }
 }
 
 abstract class _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   @override
   Map<String, Object> toMap() => {
+    "arguments": arguments,
+    "expression": expression,
     "kind": kind,
     "name": name,
-    "expression": expression,
-    "arguments": arguments,
   };
 }
 
 class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   bool _finished = false;
 
+  int _length;
+  int _offset;
   String _text;
-  int _offset;
-  int _length;
 
   @override
-  String get text => _text ??= '';
+  int get length => _length ??= 0;
 
   /**
-   * Text of the documentation comment, with '\r\n' replaced by '\n'.
-   *
-   * References appearing within the doc comment in square brackets are not
-   * specially encoded.
+   * Length of the documentation comment (prior to replacing '\r\n' with '\n').
    */
-  void set text(String _value) {
+  void set length(int _value) {
     assert(!_finished);
-    _text = _value;
+    assert(_value == null || _value >= 0);
+    _length = _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);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
-  int get length => _length ??= 0;
+  String get text => _text ??= '';
 
   /**
-   * Length of the documentation comment (prior to replacing '\r\n' with '\n').
+   * 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 length(int _value) {
+  void set text(String _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _length = _value;
+    _text = _value;
   }
 
-  UnlinkedDocumentationCommentBuilder({String text, int offset, int length})
-    : _text = text,
+  UnlinkedDocumentationCommentBuilder({int length, int offset, String text})
+    : _length = length,
       _offset = offset,
-      _length = length;
+      _text = text;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_text;
     if (_text != null) {
       offset_text = fbBuilder.writeString(_text);
     }
     fbBuilder.startTable();
-    if (offset_text != null) {
-      fbBuilder.addOffset(0, offset_text);
+    if (_length != null && _length != 0) {
+      fbBuilder.addUint32(0, _length);
     }
     if (_offset != null && _offset != 0) {
       fbBuilder.addUint32(1, _offset);
     }
-    if (_length != null && _length != 0) {
-      fbBuilder.addUint32(2, _length);
+    if (offset_text != null) {
+      fbBuilder.addOffset(2, offset_text);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedDocumentationCommentReader extends fb.TableReader<_UnlinkedDocumentationCommentImpl> {
   const _UnlinkedDocumentationCommentReader();
 
   @override
   _UnlinkedDocumentationCommentImpl createObject(fb.BufferPointer bp) => new _UnlinkedDocumentationCommentImpl(bp);
 }
 
 class _UnlinkedDocumentationCommentImpl extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   final fb.BufferPointer _bp;
 
   _UnlinkedDocumentationCommentImpl(this._bp);
 
+  int _length;
+  int _offset;
   String _text;
-  int _offset;
-  int _length;
 
   @override
-  String get text {
-    _text ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _text;
+  int get length {
+    _length ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    return _length;
   }
 
   @override
   int get offset {
     _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _offset;
   }
 
   @override
-  int get length {
-    _length ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
-    return _length;
+  String get text {
+    _text ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    return _text;
   }
 }
 
 abstract class _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   @override
   Map<String, Object> toMap() => {
+    "length": length,
+    "offset": offset,
     "text": text,
-    "offset": offset,
-    "length": length,
   };
 }
 
 class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
-  List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedEnumValueBuilder> _values;
 
   @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this enum.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
+  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
   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);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
-  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<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * Annotations for this enum.
-   */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _annotations = _value;
-  }
-
-  @override
   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<UnlinkedConstBuilder> annotations, List<UnlinkedEnumValueBuilder> values})
-    : _name = name,
+  UnlinkedEnumBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedEnumValueBuilder> values})
+    : _annotations = annotations,
+      _documentationComment = documentationComment,
+      _name = name,
       _nameOffset = nameOffset,
-      _documentationComment = documentationComment,
-      _annotations = annotations,
       _values = values;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_documentationComment;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
-    fb.Offset offset_annotations;
     fb.Offset offset_values;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
     }
     if (!(_values == null || _values.isEmpty)) {
       offset_values = fbBuilder.writeList(_values.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
+    }
+    if (offset_documentationComment != null) {
+      fbBuilder.addOffset(1, offset_documentationComment);
+    }
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+      fbBuilder.addOffset(2, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
-    }
-    if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
-    }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
+      fbBuilder.addUint32(3, _nameOffset);
     }
     if (offset_values != null) {
       fbBuilder.addOffset(4, offset_values);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedEnumReader extends fb.TableReader<_UnlinkedEnumImpl> {
   const _UnlinkedEnumReader();
 
   @override
   _UnlinkedEnumImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumImpl(bp);
 }
 
 class _UnlinkedEnumImpl extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
-  List<idl.UnlinkedConst> _annotations;
   List<idl.UnlinkedEnumValue> _values;
 
   @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
+  idl.UnlinkedDocumentationComment get documentationComment {
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    return _documentationComment;
+  }
+
+  @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _nameOffset;
   }
 
   @override
-  idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
-    return _documentationComment;
-  }
-
-  @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
-  }
-
-  @override
   List<idl.UnlinkedEnumValue> get values {
     _values ??= const fb.ListReader<idl.UnlinkedEnumValue>(const _UnlinkedEnumValueReader()).vTableGet(_bp, 4, const <idl.UnlinkedEnumValue>[]);
     return _values;
   }
 }
 
 abstract class _UnlinkedEnumMixin implements idl.UnlinkedEnum {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "annotations": annotations,
     "values": values,
   };
 }
 
 class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   bool _finished = false;
 
+  UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
+
+  @override
+  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;
+  }
 
   @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);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
-  @override
-  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;
-  }
-
-  UnlinkedEnumValueBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment})
-    : _name = name,
-      _nameOffset = nameOffset,
-      _documentationComment = documentationComment;
+  UnlinkedEnumValueBuilder({UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset})
+    : _documentationComment = documentationComment,
+      _name = name,
+      _nameOffset = nameOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_documentationComment;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
+    if (_documentationComment != null) {
+      offset_documentationComment = _documentationComment.finish(fbBuilder);
+    }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
-    if (_documentationComment != null) {
-      offset_documentationComment = _documentationComment.finish(fbBuilder);
+    fbBuilder.startTable();
+    if (offset_documentationComment != null) {
+      fbBuilder.addOffset(0, offset_documentationComment);
     }
-    fbBuilder.startTable();
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+      fbBuilder.addOffset(1, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
-    }
-    if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
+      fbBuilder.addUint32(2, _nameOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedEnumValueReader extends fb.TableReader<_UnlinkedEnumValueImpl> {
   const _UnlinkedEnumValueReader();
 
   @override
   _UnlinkedEnumValueImpl createObject(fb.BufferPointer bp) => new _UnlinkedEnumValueImpl(bp);
 }
 
 class _UnlinkedEnumValueImpl extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   final fb.BufferPointer _bp;
 
   _UnlinkedEnumValueImpl(this._bp);
 
+  idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
+
+  @override
+  idl.UnlinkedDocumentationComment get documentationComment {
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 0, null);
+    return _documentationComment;
+  }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _nameOffset;
   }
-
-  @override
-  idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
-    return _documentationComment;
-  }
 }
 
 abstract class _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
   @override
   Map<String, Object> toMap() => {
+    "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
   };
 }
 
 class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  List<UnlinkedConstructorInitializerBuilder> _constantInitializers;
+  UnlinkedDocumentationCommentBuilder _documentationComment;
+  int _inferredReturnTypeSlot;
+  bool _isAbstract;
+  bool _isConst;
+  bool _isExternal;
+  bool _isFactory;
+  bool _isStatic;
+  idl.UnlinkedExecutableKind _kind;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
-  List<UnlinkedConstBuilder> _annotations;
+  List<UnlinkedParamBuilder> _parameters;
+  EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  EntityRefBuilder _returnType;
-  List<UnlinkedParamBuilder> _parameters;
-  idl.UnlinkedExecutableKind _kind;
-  bool _isAbstract;
-  bool _isStatic;
-  bool _isConst;
-  bool _isFactory;
-  bool _isExternal;
-  int _inferredReturnTypeSlot;
-  List<UnlinkedConstructorInitializerBuilder> _constantInitializers;
 
   @override
-  String get name => _name ??= '';
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
-   * 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.
+   * Annotations for this executable.
    */
-  void set name(String _value) {
+  void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
-    _name = _value;
+    _annotations = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ??= 0;
+  List<UnlinkedConstructorInitializerBuilder> get constantInitializers => _constantInitializers ??= <UnlinkedConstructorInitializerBuilder>[];
 
   /**
-   * 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(); }").
+   * If a constant [UnlinkedExecutableKind.constructor], the constructor
+   * initializers.  Otherwise empty.
    */
-  void set nameOffset(int _value) {
+  void set constantInitializers(List<UnlinkedConstructorInitializerBuilder> _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _nameOffset = _value;
+    _constantInitializers = _value;
   }
 
   @override
   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<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+  int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
 
   /**
-   * Annotations for this executable.
+   * If this executable's return type is inferable, nonzero slot id
+   * identifying which entry in [LinkedUnit.types] contains the inferred
+   * return type.  If there is no matching entry in [LinkedUnit.types], then
+   * no return type was inferred for this variable, so its static type is
+   * `dynamic`.
    */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
+  void set inferredReturnTypeSlot(int _value) {
     assert(!_finished);
-    _annotations = _value;
-  }
-
-  @override
-  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
-  EntityRefBuilder get returnType => _returnType;
-
-  /**
-   * Declared return type of the executable.  Absent if the executable is a
-   * constructor or the return type is implicit.
-   */
-  void set returnType(EntityRefBuilder _value) {
-    assert(!_finished);
-    _returnType = _value;
-  }
-
-  @override
-  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
-  idl.UnlinkedExecutableKind get kind => _kind ??= idl.UnlinkedExecutableKind.functionOrMethod;
-
-  /**
-   * The kind of the executable (function/method, getter, setter, or
-   * constructor).
-   */
-  void set kind(idl.UnlinkedExecutableKind _value) {
-    assert(!_finished);
-    _kind = _value;
+    assert(_value == null || _value >= 0);
+    _inferredReturnTypeSlot = _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 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 isExternal => _isExternal ??= false;
+
+  /**
+   * Indicates whether the executable is declared using the `external` keyword.
+   */
+  void set isExternal(bool _value) {
+    assert(!_finished);
+    _isExternal = _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 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;
+  idl.UnlinkedExecutableKind get kind => _kind ??= idl.UnlinkedExecutableKind.functionOrMethod;
 
   /**
-   * Indicates whether the executable is declared using the `const` keyword.
+   * The kind of the executable (function/method, getter, setter, or
+   * constructor).
    */
-  void set isConst(bool _value) {
+  void set kind(idl.UnlinkedExecutableKind _value) {
     assert(!_finished);
-    _isConst = _value;
+    _kind = _value;
   }
 
   @override
-  bool get isFactory => _isFactory ??= false;
+  String get name => _name ??= '';
 
   /**
-   * Indicates whether the executable is declared using the `factory` keyword.
+   * 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 isFactory(bool _value) {
+  void set name(String _value) {
     assert(!_finished);
-    _isFactory = _value;
+    _name = _value;
   }
 
   @override
-  bool get isExternal => _isExternal ??= false;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
-   * Indicates whether the executable is declared using the `external` keyword.
+   * 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 isExternal(bool _value) {
+  void set nameOffset(int _value) {
     assert(!_finished);
-    _isExternal = _value;
+    assert(_value == null || _value >= 0);
+    _nameOffset = _value;
   }
 
   @override
-  int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
+  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
-   * If this executable's return type is inferable, nonzero slot id
-   * identifying which entry in [LinkedUnit.types] contains the inferred
-   * return type.  If there is no matching entry in [LinkedUnit.types], then
-   * no return type was inferred for this variable, so its static type is
-   * `dynamic`.
+   * 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 inferredReturnTypeSlot(int _value) {
+  void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _inferredReturnTypeSlot = _value;
+    _parameters = _value;
   }
 
   @override
-  List<UnlinkedConstructorInitializerBuilder> get constantInitializers => _constantInitializers ??= <UnlinkedConstructorInitializerBuilder>[];
+  EntityRefBuilder get returnType => _returnType;
 
   /**
-   * If a constant [UnlinkedExecutableKind.constructor], the constructor
-   * initializers.  Otherwise empty.
+   * Declared return type of the executable.  Absent if the executable is a
+   * constructor or the return type is implicit.
    */
-  void set constantInitializers(List<UnlinkedConstructorInitializerBuilder> _value) {
+  void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
-    _constantInitializers = _value;
+    _returnType = _value;
   }
 
-  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, idl.UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot, List<UnlinkedConstructorInitializerBuilder> constantInitializers})
-    : _name = name,
+  @override
+  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;
+  }
+
+  UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, List<UnlinkedConstructorInitializerBuilder> constantInitializers, UnlinkedDocumentationCommentBuilder documentationComment, int inferredReturnTypeSlot, bool isAbstract, bool isConst, bool isExternal, bool isFactory, bool isStatic, idl.UnlinkedExecutableKind kind, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
+    : _annotations = annotations,
+      _constantInitializers = constantInitializers,
+      _documentationComment = documentationComment,
+      _inferredReturnTypeSlot = inferredReturnTypeSlot,
+      _isAbstract = isAbstract,
+      _isConst = isConst,
+      _isExternal = isExternal,
+      _isFactory = isFactory,
+      _isStatic = isStatic,
+      _kind = kind,
+      _name = name,
       _nameOffset = nameOffset,
-      _documentationComment = documentationComment,
-      _annotations = annotations,
-      _typeParameters = typeParameters,
+      _parameters = parameters,
       _returnType = returnType,
-      _parameters = parameters,
-      _kind = kind,
-      _isAbstract = isAbstract,
-      _isStatic = isStatic,
-      _isConst = isConst,
-      _isFactory = isFactory,
-      _isExternal = isExternal,
-      _inferredReturnTypeSlot = inferredReturnTypeSlot,
-      _constantInitializers = constantInitializers;
+      _typeParameters = typeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_constantInitializers;
+    fb.Offset offset_documentationComment;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
-    fb.Offset offset_annotations;
+    fb.Offset offset_parameters;
+    fb.Offset offset_returnType;
     fb.Offset offset_typeParameters;
-    fb.Offset offset_returnType;
-    fb.Offset offset_parameters;
-    fb.Offset offset_constantInitializers;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (!(_constantInitializers == null || _constantInitializers.isEmpty)) {
+      offset_constantInitializers = fbBuilder.writeList(_constantInitializers.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
+    if (!(_parameters == null || _parameters.isEmpty)) {
+      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_returnType != null) {
+      offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
-    if (_returnType != null) {
-      offset_returnType = _returnType.finish(fbBuilder);
+    fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
     }
-    if (!(_parameters == null || _parameters.isEmpty)) {
-      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
-    }
-    if (!(_constantInitializers == null || _constantInitializers.isEmpty)) {
-      offset_constantInitializers = fbBuilder.writeList(_constantInitializers.map((b) => b.finish(fbBuilder)).toList());
-    }
-    fbBuilder.startTable();
-    if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
-    }
-    if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
+    if (offset_constantInitializers != null) {
+      fbBuilder.addOffset(1, offset_constantInitializers);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
+    if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
+      fbBuilder.addUint32(3, _inferredReturnTypeSlot);
+    }
+    if (_isAbstract == true) {
+      fbBuilder.addBool(4, true);
+    }
+    if (_isConst == true) {
+      fbBuilder.addBool(5, true);
+    }
+    if (_isExternal == true) {
+      fbBuilder.addBool(6, true);
+    }
+    if (_isFactory == true) {
+      fbBuilder.addBool(7, true);
+    }
+    if (_isStatic == true) {
+      fbBuilder.addBool(8, true);
+    }
+    if (_kind != null && _kind != idl.UnlinkedExecutableKind.functionOrMethod) {
+      fbBuilder.addUint32(9, _kind.index);
+    }
+    if (offset_name != null) {
+      fbBuilder.addOffset(10, offset_name);
+    }
+    if (_nameOffset != null && _nameOffset != 0) {
+      fbBuilder.addUint32(11, _nameOffset);
+    }
+    if (offset_parameters != null) {
+      fbBuilder.addOffset(12, offset_parameters);
+    }
+    if (offset_returnType != null) {
+      fbBuilder.addOffset(13, offset_returnType);
     }
     if (offset_typeParameters != null) {
-      fbBuilder.addOffset(4, offset_typeParameters);
-    }
-    if (offset_returnType != null) {
-      fbBuilder.addOffset(5, offset_returnType);
-    }
-    if (offset_parameters != null) {
-      fbBuilder.addOffset(6, offset_parameters);
-    }
-    if (_kind != null && _kind != idl.UnlinkedExecutableKind.functionOrMethod) {
-      fbBuilder.addUint32(7, _kind.index);
-    }
-    if (_isAbstract == true) {
-      fbBuilder.addBool(8, true);
-    }
-    if (_isStatic == true) {
-      fbBuilder.addBool(9, true);
-    }
-    if (_isConst == true) {
-      fbBuilder.addBool(10, true);
-    }
-    if (_isFactory == true) {
-      fbBuilder.addBool(11, true);
-    }
-    if (_isExternal == true) {
-      fbBuilder.addBool(12, true);
-    }
-    if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
-      fbBuilder.addUint32(13, _inferredReturnTypeSlot);
-    }
-    if (offset_constantInitializers != null) {
-      fbBuilder.addOffset(14, offset_constantInitializers);
+      fbBuilder.addOffset(14, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
 
 class _UnlinkedExecutableImpl extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   final fb.BufferPointer _bp;
 
   _UnlinkedExecutableImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  List<idl.UnlinkedConstructorInitializer> _constantInitializers;
+  idl.UnlinkedDocumentationComment _documentationComment;
+  int _inferredReturnTypeSlot;
+  bool _isAbstract;
+  bool _isConst;
+  bool _isExternal;
+  bool _isFactory;
+  bool _isStatic;
+  idl.UnlinkedExecutableKind _kind;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
-  List<idl.UnlinkedConst> _annotations;
+  List<idl.UnlinkedParam> _parameters;
+  idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
-  idl.EntityRef _returnType;
-  List<idl.UnlinkedParam> _parameters;
-  idl.UnlinkedExecutableKind _kind;
-  bool _isAbstract;
-  bool _isStatic;
-  bool _isConst;
-  bool _isFactory;
-  bool _isExternal;
-  int _inferredReturnTypeSlot;
-  List<idl.UnlinkedConstructorInitializer> _constantInitializers;
 
   @override
-  String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _name;
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
   }
 
   @override
-  int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _nameOffset;
+  List<idl.UnlinkedConstructorInitializer> get constantInitializers {
+    _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 1, const <idl.UnlinkedConstructorInitializer>[]);
+    return _constantInitializers;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
+  int get inferredReturnTypeSlot {
+    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    return _inferredReturnTypeSlot;
+  }
+
+  @override
+  bool get isAbstract {
+    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    return _isAbstract;
+  }
+
+  @override
+  bool get isConst {
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    return _isConst;
+  }
+
+  @override
+  bool get isExternal {
+    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    return _isExternal;
+  }
+
+  @override
+  bool get isFactory {
+    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 7, false);
+    return _isFactory;
+  }
+
+  @override
+  bool get isStatic {
+    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 8, false);
+    return _isStatic;
+  }
+
+  @override
+  idl.UnlinkedExecutableKind get kind {
+    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 9, idl.UnlinkedExecutableKind.functionOrMethod);
+    return _kind;
+  }
+
+  @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 10, '');
+    return _name;
+  }
+
+  @override
+  int get nameOffset {
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 11, 0);
+    return _nameOffset;
+  }
+
+  @override
+  List<idl.UnlinkedParam> get parameters {
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 12, const <idl.UnlinkedParam>[]);
+    return _parameters;
+  }
+
+  @override
+  idl.EntityRef get returnType {
+    _returnType ??= const _EntityRefReader().vTableGet(_bp, 13, null);
+    return _returnType;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 14, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
-
-  @override
-  idl.EntityRef get returnType {
-    _returnType ??= const _EntityRefReader().vTableGet(_bp, 5, null);
-    return _returnType;
-  }
-
-  @override
-  List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedParam>[]);
-    return _parameters;
-  }
-
-  @override
-  idl.UnlinkedExecutableKind get kind {
-    _kind ??= const _UnlinkedExecutableKindReader().vTableGet(_bp, 7, idl.UnlinkedExecutableKind.functionOrMethod);
-    return _kind;
-  }
-
-  @override
-  bool get isAbstract {
-    _isAbstract ??= const fb.BoolReader().vTableGet(_bp, 8, false);
-    return _isAbstract;
-  }
-
-  @override
-  bool get isStatic {
-    _isStatic ??= const fb.BoolReader().vTableGet(_bp, 9, false);
-    return _isStatic;
-  }
-
-  @override
-  bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 10, false);
-    return _isConst;
-  }
-
-  @override
-  bool get isFactory {
-    _isFactory ??= const fb.BoolReader().vTableGet(_bp, 11, false);
-    return _isFactory;
-  }
-
-  @override
-  bool get isExternal {
-    _isExternal ??= const fb.BoolReader().vTableGet(_bp, 12, false);
-    return _isExternal;
-  }
-
-  @override
-  int get inferredReturnTypeSlot {
-    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 13, 0);
-    return _inferredReturnTypeSlot;
-  }
-
-  @override
-  List<idl.UnlinkedConstructorInitializer> get constantInitializers {
-    _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 14, const <idl.UnlinkedConstructorInitializer>[]);
-    return _constantInitializers;
-  }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "constantInitializers": constantInitializers,
+    "documentationComment": documentationComment,
+    "inferredReturnTypeSlot": inferredReturnTypeSlot,
+    "isAbstract": isAbstract,
+    "isConst": isConst,
+    "isExternal": isExternal,
+    "isFactory": isFactory,
+    "isStatic": isStatic,
+    "kind": kind,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "annotations": annotations,
+    "parameters": parameters,
+    "returnType": returnType,
     "typeParameters": typeParameters,
-    "returnType": returnType,
-    "parameters": parameters,
-    "kind": kind,
-    "isAbstract": isAbstract,
-    "isStatic": isStatic,
-    "isConst": isConst,
-    "isFactory": isFactory,
-    "isExternal": isExternal,
-    "inferredReturnTypeSlot": inferredReturnTypeSlot,
-    "constantInitializers": constantInitializers,
   };
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
   int _offset;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  List<UnlinkedConstBuilder> _annotations;
+
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this export directive.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
 
   @override
   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;
-
-  /**
-   * 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;
 
   /**
    * 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;
   }
 
   @override
-  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+  int get uriOffset => _uriOffset ??= 0;
 
   /**
-   * Annotations for this export directive.
+   * Offset of the URI string (including quotes) relative to the beginning of
+   * the file.
    */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
+  void set uriOffset(int _value) {
     assert(!_finished);
-    _annotations = _value;
+    assert(_value == null || _value >= 0);
+    _uriOffset = _value;
   }
 
-  UnlinkedExportNonPublicBuilder({int offset, int uriOffset, int uriEnd, List<UnlinkedConstBuilder> annotations})
-    : _offset = offset,
-      _uriOffset = uriOffset,
+  UnlinkedExportNonPublicBuilder({List<UnlinkedConstBuilder> annotations, int offset, int uriEnd, int uriOffset})
+    : _annotations = annotations,
+      _offset = offset,
       _uriEnd = uriEnd,
-      _annotations = annotations;
+      _uriOffset = uriOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
+    }
     if (_offset != null && _offset != 0) {
-      fbBuilder.addUint32(0, _offset);
-    }
-    if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(1, _uriOffset);
+      fbBuilder.addUint32(1, _offset);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(2, _uriEnd);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
+    if (_uriOffset != null && _uriOffset != 0) {
+      fbBuilder.addUint32(3, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExportNonPublicReader extends fb.TableReader<_UnlinkedExportNonPublicImpl> {
   const _UnlinkedExportNonPublicReader();
 
   @override
   _UnlinkedExportNonPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportNonPublicImpl(bp);
 }
 
 class _UnlinkedExportNonPublicImpl extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportNonPublicImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
   int _offset;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  List<idl.UnlinkedConst> _annotations;
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
 
   @override
   int get offset {
-    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
+    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _offset;
   }
 
   @override
-  int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _uriOffset;
-  }
-
-  @override
   int get uriEnd {
     _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _uriEnd;
   }
 
   @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
+  int get uriOffset {
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    return _uriOffset;
   }
 }
 
 abstract class _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
     "offset": offset,
+    "uriEnd": uriEnd,
     "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-    "annotations": annotations,
   };
 }
 
 class UnlinkedExportPublicBuilder extends Object with _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   bool _finished = false;
 
+  List<UnlinkedCombinatorBuilder> _combinators;
   String _uri;
-  List<UnlinkedCombinatorBuilder> _combinators;
+
+  @override
+  List<UnlinkedCombinatorBuilder> get combinators => _combinators ??= <UnlinkedCombinatorBuilder>[];
+
+  /**
+   * Combinators contained in this import declaration.
+   */
+  void set combinators(List<UnlinkedCombinatorBuilder> _value) {
+    assert(!_finished);
+    _combinators = _value;
+  }
 
   @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<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})
-    : _uri = uri,
-      _combinators = combinators;
+  UnlinkedExportPublicBuilder({List<UnlinkedCombinatorBuilder> combinators, String uri})
+    : _combinators = combinators,
+      _uri = uri;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_combinators;
     fb.Offset offset_uri;
-    fb.Offset offset_combinators;
+    if (!(_combinators == null || _combinators.isEmpty)) {
+      offset_combinators = fbBuilder.writeList(_combinators.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
-    if (!(_combinators == null || _combinators.isEmpty)) {
-      offset_combinators = fbBuilder.writeList(_combinators.map((b) => b.finish(fbBuilder)).toList());
+    fbBuilder.startTable();
+    if (offset_combinators != null) {
+      fbBuilder.addOffset(0, offset_combinators);
     }
-    fbBuilder.startTable();
     if (offset_uri != null) {
-      fbBuilder.addOffset(0, offset_uri);
-    }
-    if (offset_combinators != null) {
-      fbBuilder.addOffset(1, offset_combinators);
+      fbBuilder.addOffset(1, offset_uri);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExportPublicReader extends fb.TableReader<_UnlinkedExportPublicImpl> {
   const _UnlinkedExportPublicReader();
 
   @override
   _UnlinkedExportPublicImpl createObject(fb.BufferPointer bp) => new _UnlinkedExportPublicImpl(bp);
 }
 
 class _UnlinkedExportPublicImpl extends Object with _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   final fb.BufferPointer _bp;
 
   _UnlinkedExportPublicImpl(this._bp);
 
+  List<idl.UnlinkedCombinator> _combinators;
   String _uri;
-  List<idl.UnlinkedCombinator> _combinators;
+
+  @override
+  List<idl.UnlinkedCombinator> get combinators {
+    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 0, const <idl.UnlinkedCombinator>[]);
+    return _combinators;
+  }
 
   @override
   String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _uri ??= const fb.StringReader().vTableGet(_bp, 1, '');
     return _uri;
   }
-
-  @override
-  List<idl.UnlinkedCombinator> get combinators {
-    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 1, const <idl.UnlinkedCombinator>[]);
-    return _combinators;
-  }
 }
 
 abstract class _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
   @override
   Map<String, Object> toMap() => {
+    "combinators": combinators,
     "uri": uri,
-    "combinators": combinators,
   };
 }
 
 class UnlinkedImportBuilder extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
   bool _finished = false;
 
-  String _uri;
-  int _offset;
   List<UnlinkedConstBuilder> _annotations;
-  int _prefixReference;
   List<UnlinkedCombinatorBuilder> _combinators;
   bool _isDeferred;
   bool _isImplicit;
+  int _offset;
+  int _prefixOffset;
+  int _prefixReference;
+  String _uri;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  int _prefixOffset;
-
-  @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);
-    assert(_value == null || _value >= 0);
-    _offset = _value;
-  }
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this import declaration.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _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);
-    assert(_value == null || _value >= 0);
-    _prefixReference = _value;
-  }
-
-  @override
   List<UnlinkedCombinatorBuilder> get combinators => _combinators ??= <UnlinkedCombinatorBuilder>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
     assert(!_finished);
     _combinators = _value;
   }
 
@@ skipping 13 matching lines @@
 
   /**
    * Indicates whether the import declaration is implicit.
    */
   void set isImplicit(bool _value) {
     assert(!_finished);
     _isImplicit = _value;
   }
 
   @override
-  int get uriOffset => _uriOffset ??= 0;
+  int get offset => _offset ??= 0;
 
   /**
-   * Offset of the URI string (including quotes) relative to the beginning of
-   * the file.  If [isImplicit] is true, zero.
+   * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
+   * is true, zero.
    */
-  void set uriOffset(int _value) {
+  void set offset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
-    _uriOffset = _value;
+    _offset = _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);
+    assert(_value == null || _value >= 0);
+    _prefixOffset = _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);
+    assert(_value == null || _value >= 0);
+    _prefixReference = _value;
+  }
+
+  @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 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 uriOffset => _uriOffset ??= 0;
 
   /**
-   * Offset of the prefix name relative to the beginning of the file, or zero
-   * if there is no prefix.
+   * Offset of the URI string (including quotes) relative to the beginning of
+   * the file.  If [isImplicit] is true, zero.
    */
-  void set prefixOffset(int _value) {
+  void set uriOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
-    _prefixOffset = _value;
+    _uriOffset = _value;
   }
 
-  UnlinkedImportBuilder({String uri, int offset, List<UnlinkedConstBuilder> annotations, int prefixReference, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int uriOffset, int uriEnd, int prefixOffset})
-    : _uri = uri,
-      _offset = offset,
-      _annotations = annotations,
-      _prefixReference = prefixReference,
+  UnlinkedImportBuilder({List<UnlinkedConstBuilder> annotations, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int offset, int prefixOffset, int prefixReference, String uri, int uriEnd, int uriOffset})
+    : _annotations = annotations,
       _combinators = combinators,
       _isDeferred = isDeferred,
       _isImplicit = isImplicit,
-      _uriOffset = uriOffset,
+      _offset = offset,
+      _prefixOffset = prefixOffset,
+      _prefixReference = prefixReference,
+      _uri = uri,
       _uriEnd = uriEnd,
-      _prefixOffset = prefixOffset;
+      _uriOffset = uriOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
-    fb.Offset offset_uri;
     fb.Offset offset_annotations;
     fb.Offset offset_combinators;
-    if (_uri != null) {
-      offset_uri = fbBuilder.writeString(_uri);
-    }
+    fb.Offset offset_uri;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_combinators == null || _combinators.isEmpty)) {
       offset_combinators = fbBuilder.writeList(_combinators.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (_uri != null) {
+      offset_uri = fbBuilder.writeString(_uri);
+    }
     fbBuilder.startTable();
-    if (offset_uri != null) {
-      fbBuilder.addOffset(0, offset_uri);
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
+    }
+    if (offset_combinators != null) {
+      fbBuilder.addOffset(1, offset_combinators);
+    }
+    if (_isDeferred == true) {
+      fbBuilder.addBool(2, true);
+    }
+    if (_isImplicit == true) {
+      fbBuilder.addBool(3, true);
     }
     if (_offset != null && _offset != 0) {
-      fbBuilder.addUint32(1, _offset);
+      fbBuilder.addUint32(4, _offset);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(2, offset_annotations);
+    if (_prefixOffset != null && _prefixOffset != 0) {
+      fbBuilder.addUint32(5, _prefixOffset);
     }
     if (_prefixReference != null && _prefixReference != 0) {
-      fbBuilder.addUint32(3, _prefixReference);
+      fbBuilder.addUint32(6, _prefixReference);
     }
-    if (offset_combinators != null) {
-      fbBuilder.addOffset(4, offset_combinators);
-    }
-    if (_isDeferred == true) {
-      fbBuilder.addBool(5, true);
-    }
-    if (_isImplicit == true) {
-      fbBuilder.addBool(6, true);
-    }
-    if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(7, _uriOffset);
+    if (offset_uri != null) {
+      fbBuilder.addOffset(7, offset_uri);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(8, _uriEnd);
     }
-    if (_prefixOffset != null && _prefixOffset != 0) {
-      fbBuilder.addUint32(9, _prefixOffset);
+    if (_uriOffset != null && _uriOffset != 0) {
+      fbBuilder.addUint32(9, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedImportReader extends fb.TableReader<_UnlinkedImportImpl> {
   const _UnlinkedImportReader();
 
   @override
   _UnlinkedImportImpl createObject(fb.BufferPointer bp) => new _UnlinkedImportImpl(bp);
 }
 
 class _UnlinkedImportImpl extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
   final fb.BufferPointer _bp;
 
   _UnlinkedImportImpl(this._bp);
 
-  String _uri;
-  int _offset;
   List<idl.UnlinkedConst> _annotations;
-  int _prefixReference;
   List<idl.UnlinkedCombinator> _combinators;
   bool _isDeferred;
   bool _isImplicit;
+  int _offset;
+  int _prefixOffset;
+  int _prefixReference;
+  String _uri;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  int _prefixOffset;
-
-  @override
-  String get uri {
-    _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _uri;
-  }
-
-  @override
-  int get offset {
-    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _offset;
-  }
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
-  int get prefixReference {
-    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
-    return _prefixReference;
-  }
-
-  @override
   List<idl.UnlinkedCombinator> get combinators {
-    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 4, const <idl.UnlinkedCombinator>[]);
+    _combinators ??= const fb.ListReader<idl.UnlinkedCombinator>(const _UnlinkedCombinatorReader()).vTableGet(_bp, 1, const <idl.UnlinkedCombinator>[]);
     return _combinators;
   }
 
   @override
   bool get isDeferred {
-    _isDeferred ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    _isDeferred ??= const fb.BoolReader().vTableGet(_bp, 2, false);
     return _isDeferred;
   }
 
   @override
   bool get isImplicit {
-    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 6, false);
+    _isImplicit ??= const fb.BoolReader().vTableGet(_bp, 3, false);
     return _isImplicit;
   }
 
   @override
-  int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
-    return _uriOffset;
+  int get offset {
+    _offset ??= const fb.Uint32Reader().vTableGet(_bp, 4, 0);
+    return _offset;
   }
 
   @override
+  int get prefixOffset {
+    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 5, 0);
+    return _prefixOffset;
+  }
+
+  @override
+  int get prefixReference {
+    _prefixReference ??= const fb.Uint32Reader().vTableGet(_bp, 6, 0);
+    return _prefixReference;
+  }
+
+  @override
+  String get uri {
+    _uri ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    return _uri;
+  }
+
+  @override
   int get uriEnd {
     _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
     return _uriEnd;
   }
 
   @override
-  int get prefixOffset {
-    _prefixOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
-    return _prefixOffset;
+  int get uriOffset {
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    return _uriOffset;
   }
 }
 
 abstract class _UnlinkedImportMixin implements idl.UnlinkedImport {
   @override
   Map<String, Object> toMap() => {
-    "uri": uri,
-    "offset": offset,
     "annotations": annotations,
-    "prefixReference": prefixReference,
     "combinators": combinators,
     "isDeferred": isDeferred,
     "isImplicit": isImplicit,
+    "offset": offset,
+    "prefixOffset": prefixOffset,
+    "prefixReference": prefixReference,
+    "uri": uri,
+    "uriEnd": uriEnd,
     "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-    "prefixOffset": prefixOffset,
   };
 }
 
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  UnlinkedConstBuilder _defaultValue;
+  int _inferredTypeSlot;
+  bool _isFunctionTyped;
+  bool _isInitializingFormal;
+  idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
-  List<UnlinkedConstBuilder> _annotations;
+  List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _type;
-  List<UnlinkedParamBuilder> _parameters;
-  idl.UnlinkedParamKind _kind;
-  bool _isFunctionTyped;
-  bool _isInitializingFormal;
-  int _inferredTypeSlot;
-  UnlinkedConstBuilder _defaultValue;
-
-  @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);
-    assert(_value == null || _value >= 0);
-    _nameOffset = _value;
-  }
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this parameter.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
   }
 
   @override
-  EntityRefBuilder get type => _type;
+  UnlinkedConstBuilder get defaultValue => _defaultValue;
 
   /**
-   * If [isFunctionTyped] is `true`, the declared return type.  If
-   * [isFunctionTyped] is `false`, the declared type.  Absent if the type is
-   * implicit.
+   * If the parameter has a default value, the constant expression in the
+   * default value.  Note that the presence of this expression does not mean
+   * that it is a valid, check [UnlinkedConst.isInvalid].
    */
-  void set type(EntityRefBuilder _value) {
+  void set defaultValue(UnlinkedConstBuilder _value) {
     assert(!_finished);
-    _type = _value;
+    _defaultValue = _value;
   }
 
   @override
-  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
+  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
-   * If [isFunctionTyped] is `true`, the parameters of the function type.
+   * If this parameter's type is inferable, nonzero slot id identifying which
+   * entry in [LinkedLibrary.types] contains the inferred type.  If there is no
+   * matching entry in [LinkedLibrary.types], then no type was inferred for
+   * this variable, so its static type is `dynamic`.
+   *
+   * Note that although strong mode considers initializing formals to be
+   * inferable, they are not marked as such in the summary; if their type is
+   * not specified, they always inherit the static type of the corresponding
+   * field.
    */
-  void set parameters(List<UnlinkedParamBuilder> _value) {
+  void set inferredTypeSlot(int _value) {
     assert(!_finished);
-    _parameters = _value;
+    assert(_value == null || _value >= 0);
+    _inferredTypeSlot = _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
   idl.UnlinkedParamKind get kind => _kind ??= idl.UnlinkedParamKind.required;
 
   /**
    * Kind of the parameter.
    */
   void set kind(idl.UnlinkedParamKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
-  bool get isFunctionTyped => _isFunctionTyped ??= false;
+  String get name => _name ??= '';
 
   /**
-   * Indicates whether this is a function-typed parameter.
+   * Name of the parameter.
    */
-  void set isFunctionTyped(bool _value) {
+  void set name(String _value) {
     assert(!_finished);
-    _isFunctionTyped = _value;
+    _name = _value;
   }
 
   @override
-  bool get isInitializingFormal => _isInitializingFormal ??= false;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
-   * Indicates whether this is an initializing formal parameter (i.e. it is
-   * declared using `this.` syntax).
+   * Offset of the parameter name relative to the beginning of the file.
    */
-  void set isInitializingFormal(bool _value) {
+  void set nameOffset(int _value) {
     assert(!_finished);
-    _isInitializingFormal = _value;
+    assert(_value == null || _value >= 0);
+    _nameOffset = _value;
   }
 
   @override
-  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
+  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
-   * If this parameter's type is inferable, nonzero slot id identifying which
-   * entry in [LinkedLibrary.types] contains the inferred type.  If there is no
-   * matching entry in [LinkedLibrary.types], then no type was inferred for
-   * this variable, so its static type is `dynamic`.
-   *
-   * Note that although strong mode considers initializing formals to be
-   * inferable, they are not marked as such in the summary; if their type is
-   * not specified, they always inherit the static type of the corresponding
-   * field.
+   * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
-  void set inferredTypeSlot(int _value) {
+  void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _inferredTypeSlot = _value;
+    _parameters = _value;
   }
 
   @override
-  UnlinkedConstBuilder get defaultValue => _defaultValue;
+  EntityRefBuilder get type => _type;
 
   /**
-   * If the parameter has a default value, the constant expression in the
-   * default value.  Note that the presence of this expression does not mean
-   * that it is a valid, check [UnlinkedConst.isInvalid].
+   * If [isFunctionTyped] is `true`, the declared return type.  If
+   * [isFunctionTyped] is `false`, the declared type.  Absent if the type is
+   * implicit.
    */
-  void set defaultValue(UnlinkedConstBuilder _value) {
+  void set type(EntityRefBuilder _value) {
     assert(!_finished);
-    _defaultValue = _value;
+    _type = _value;
   }
 
-  UnlinkedParamBuilder({String name, int nameOffset, List<UnlinkedConstBuilder> annotations, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot, UnlinkedConstBuilder defaultValue})
-    : _name = name,
-      _nameOffset = nameOffset,
-      _annotations = annotations,
-      _type = type,
-      _parameters = parameters,
-      _kind = kind,
+  UnlinkedParamBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedConstBuilder defaultValue, int inferredTypeSlot, bool isFunctionTyped, bool isInitializingFormal, idl.UnlinkedParamKind kind, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder type})
+    : _annotations = annotations,
+      _defaultValue = defaultValue,
+      _inferredTypeSlot = inferredTypeSlot,
       _isFunctionTyped = isFunctionTyped,
       _isInitializingFormal = isInitializingFormal,
-      _inferredTypeSlot = inferredTypeSlot,
-      _defaultValue = defaultValue;
+      _kind = kind,
+      _name = name,
+      _nameOffset = nameOffset,
+      _parameters = parameters,
+      _type = type;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_defaultValue;
     fb.Offset offset_name;
-    fb.Offset offset_annotations;
+    fb.Offset offset_parameters;
     fb.Offset offset_type;
-    fb.Offset offset_parameters;
-    fb.Offset offset_defaultValue;
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_defaultValue != null) {
+      offset_defaultValue = _defaultValue.finish(fbBuilder);
+    }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (!(_parameters == null || _parameters.isEmpty)) {
+      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
-    if (!(_parameters == null || _parameters.isEmpty)) {
-      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
+    fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
     }
-    if (_defaultValue != null) {
-      offset_defaultValue = _defaultValue.finish(fbBuilder);
+    if (offset_defaultValue != null) {
+      fbBuilder.addOffset(1, offset_defaultValue);
     }
-    fbBuilder.startTable();
-    if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+    if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
+      fbBuilder.addUint32(2, _inferredTypeSlot);
     }
-    if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
+    if (_isFunctionTyped == true) {
+      fbBuilder.addBool(3, true);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(2, offset_annotations);
-    }
-    if (offset_type != null) {
-      fbBuilder.addOffset(3, offset_type);
-    }
-    if (offset_parameters != null) {
-      fbBuilder.addOffset(4, offset_parameters);
+    if (_isInitializingFormal == true) {
+      fbBuilder.addBool(4, true);
     }
     if (_kind != null && _kind != idl.UnlinkedParamKind.required) {
       fbBuilder.addUint32(5, _kind.index);
     }
-    if (_isFunctionTyped == true) {
-      fbBuilder.addBool(6, true);
+    if (offset_name != null) {
+      fbBuilder.addOffset(6, offset_name);
     }
-    if (_isInitializingFormal == true) {
-      fbBuilder.addBool(7, true);
+    if (_nameOffset != null && _nameOffset != 0) {
+      fbBuilder.addUint32(7, _nameOffset);
     }
-    if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
-      fbBuilder.addUint32(8, _inferredTypeSlot);
+    if (offset_parameters != null) {
+      fbBuilder.addOffset(8, offset_parameters);
     }
-    if (offset_defaultValue != null) {
-      fbBuilder.addOffset(9, offset_defaultValue);
+    if (offset_type != null) {
+      fbBuilder.addOffset(9, offset_type);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
 class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.UnlinkedConst _defaultValue;
+  int _inferredTypeSlot;
+  bool _isFunctionTyped;
+  bool _isInitializingFormal;
+  idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
-  List<idl.UnlinkedConst> _annotations;
+  List<idl.UnlinkedParam> _parameters;
   idl.EntityRef _type;
-  List<idl.UnlinkedParam> _parameters;
-  idl.UnlinkedParamKind _kind;
-  bool _isFunctionTyped;
-  bool _isInitializingFormal;
-  int _inferredTypeSlot;
-  idl.UnlinkedConst _defaultValue;
-
-  @override
-  String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _name;
-  }
-
-  @override
-  int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _nameOffset;
-  }
 
   @override
   List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
-  idl.EntityRef get type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 3, null);
-    return _type;
+  idl.UnlinkedConst get defaultValue {
+    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
+    return _defaultValue;
   }
 
   @override
-  List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedParam>[]);
-    return _parameters;
+  int get inferredTypeSlot {
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    return _inferredTypeSlot;
   }
 
   @override
+  bool get isFunctionTyped {
+    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 3, false);
+    return _isFunctionTyped;
+  }
+
+  @override
+  bool get isInitializingFormal {
+    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    return _isInitializingFormal;
+  }
+
+  @override
   idl.UnlinkedParamKind get kind {
     _kind ??= const _UnlinkedParamKindReader().vTableGet(_bp, 5, idl.UnlinkedParamKind.required);
     return _kind;
   }
 
   @override
-  bool get isFunctionTyped {
-    _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 6, false);
-    return _isFunctionTyped;
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 6, '');
+    return _name;
   }
 
   @override
-  bool get isInitializingFormal {
-    _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 7, false);
-    return _isInitializingFormal;
+  int get nameOffset {
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
+    return _nameOffset;
   }
 
   @override
-  int get inferredTypeSlot {
-    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
-    return _inferredTypeSlot;
+  List<idl.UnlinkedParam> get parameters {
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 8, const <idl.UnlinkedParam>[]);
+    return _parameters;
   }
 
   @override
-  idl.UnlinkedConst get defaultValue {
-    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 9, null);
-    return _defaultValue;
+  idl.EntityRef get type {
+    _type ??= const _EntityRefReader().vTableGet(_bp, 9, null);
+    return _type;
   }
 }
 
 abstract class _UnlinkedParamMixin implements idl.UnlinkedParam {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "defaultValue": defaultValue,
+    "inferredTypeSlot": inferredTypeSlot,
+    "isFunctionTyped": isFunctionTyped,
+    "isInitializingFormal": isInitializingFormal,
+    "kind": kind,
     "name": name,
     "nameOffset": nameOffset,
-    "annotations": annotations,
+    "parameters": parameters,
     "type": type,
-    "parameters": parameters,
-    "kind": kind,
-    "isFunctionTyped": isFunctionTyped,
-    "isInitializingFormal": isInitializingFormal,
-    "inferredTypeSlot": inferredTypeSlot,
-    "defaultValue": defaultValue,
   };
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  List<UnlinkedConstBuilder> _annotations;
 
   @override
-  int get uriOffset => _uriOffset ??= 0;
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
-   * Offset of the URI string (including quotes) relative to the beginning of
-   * the file.
+   * Annotations for this part declaration.
    */
-  void set uriOffset(int _value) {
+  void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _uriOffset = _value;
+    _annotations = _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);
     assert(_value == null || _value >= 0);
     _uriEnd = _value;
   }
 
   @override
-  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+  int get uriOffset => _uriOffset ??= 0;
 
   /**
-   * Annotations for this part declaration.
+   * Offset of the URI string (including quotes) relative to the beginning of
+   * the file.
    */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
+  void set uriOffset(int _value) {
     assert(!_finished);
-    _annotations = _value;
+    assert(_value == null || _value >= 0);
+    _uriOffset = _value;
   }
 
-  UnlinkedPartBuilder({int uriOffset, int uriEnd, List<UnlinkedConstBuilder> annotations})
-    : _uriOffset = uriOffset,
+  UnlinkedPartBuilder({List<UnlinkedConstBuilder> annotations, int uriEnd, int uriOffset})
+    : _annotations = annotations,
       _uriEnd = uriEnd,
-      _annotations = annotations;
+      _uriOffset = uriOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
-    if (_uriOffset != null && _uriOffset != 0) {
-      fbBuilder.addUint32(0, _uriOffset);
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(1, _uriEnd);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(2, offset_annotations);
+    if (_uriOffset != null && _uriOffset != 0) {
+      fbBuilder.addUint32(2, _uriOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedPartReader extends fb.TableReader<_UnlinkedPartImpl> {
   const _UnlinkedPartReader();
 
   @override
   _UnlinkedPartImpl createObject(fb.BufferPointer bp) => new _UnlinkedPartImpl(bp);
 }
 
 class _UnlinkedPartImpl extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
   final fb.BufferPointer _bp;
 
   _UnlinkedPartImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  int _uriEnd;
   int _uriOffset;
-  int _uriEnd;
-  List<idl.UnlinkedConst> _annotations;
 
   @override
-  int get uriOffset {
-    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 0, 0);
-    return _uriOffset;
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
   }
 
   @override
   int get uriEnd {
     _uriEnd ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _uriEnd;
   }
 
   @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
-    return _annotations;
+  int get uriOffset {
+    _uriOffset ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    return _uriOffset;
   }
 }
 
 abstract class _UnlinkedPartMixin implements idl.UnlinkedPart {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "uriEnd": uriEnd,
     "uriOffset": uriOffset,
-    "uriEnd": uriEnd,
-    "annotations": annotations,
   };
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
   bool _finished = false;
 
+  List<UnlinkedPublicNameBuilder> _constMembers;
+  idl.ReferenceKind _kind;
   String _name;
-  idl.ReferenceKind _kind;
   int _numTypeParameters;
-  List<UnlinkedPublicNameBuilder> _constMembers;
 
   @override
-  String get name => _name ??= '';
+  List<UnlinkedPublicNameBuilder> get constMembers => _constMembers ??= <UnlinkedPublicNameBuilder>[];
 
   /**
-   * The name itself.
+   * If this [UnlinkedPublicName] is a class, the list of members which can be
+   * referenced from constants - static constant fields, static methods, and
+   * constructors.  Otherwise empty.
    */
-  void set name(String _value) {
+  void set constMembers(List<UnlinkedPublicNameBuilder> _value) {
     assert(!_finished);
-    _name = _value;
+    _constMembers = _value;
   }
 
   @override
   idl.ReferenceKind get kind => _kind ??= idl.ReferenceKind.classOrEnum;
 
   /**
    * The kind of object referred to by the name.
    */
   void set kind(idl.ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
+  String get name => _name ??= '';
+
+  /**
+   * The name itself.
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _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);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
-  @override
-  List<UnlinkedPublicNameBuilder> get constMembers => _constMembers ??= <UnlinkedPublicNameBuilder>[];
-
-  /**
-   * If this [UnlinkedPublicName] is a class, the list of members which can be
-   * referenced from constants - static constant fields, static methods, and
-   * constructors.  Otherwise empty.
-   */
-  void set constMembers(List<UnlinkedPublicNameBuilder> _value) {
-    assert(!_finished);
-    _constMembers = _value;
-  }
-
-  UnlinkedPublicNameBuilder({String name, idl.ReferenceKind kind, int numTypeParameters, List<UnlinkedPublicNameBuilder> constMembers})
-    : _name = name,
+  UnlinkedPublicNameBuilder({List<UnlinkedPublicNameBuilder> constMembers, idl.ReferenceKind kind, String name, int numTypeParameters})
+    : _constMembers = constMembers,
       _kind = kind,
-      _numTypeParameters = numTypeParameters,
-      _constMembers = constMembers;
+      _name = name,
+      _numTypeParameters = numTypeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_constMembers;
     fb.Offset offset_name;
-    fb.Offset offset_constMembers;
+    if (!(_constMembers == null || _constMembers.isEmpty)) {
+      offset_constMembers = fbBuilder.writeList(_constMembers.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
-    if (!(_constMembers == null || _constMembers.isEmpty)) {
-      offset_constMembers = fbBuilder.writeList(_constMembers.map((b) => b.finish(fbBuilder)).toList());
-    }
     fbBuilder.startTable();
-    if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+    if (offset_constMembers != null) {
+      fbBuilder.addOffset(0, offset_constMembers);
     }
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
       fbBuilder.addUint32(1, _kind.index);
     }
+    if (offset_name != null) {
+      fbBuilder.addOffset(2, offset_name);
+    }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
-      fbBuilder.addUint32(2, _numTypeParameters);
-    }
-    if (offset_constMembers != null) {
-      fbBuilder.addOffset(3, offset_constMembers);
+      fbBuilder.addUint32(3, _numTypeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedPublicNameReader extends fb.TableReader<_UnlinkedPublicNameImpl> {
   const _UnlinkedPublicNameReader();
 
   @override
   _UnlinkedPublicNameImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNameImpl(bp);
 }
 
 class _UnlinkedPublicNameImpl extends Object with _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNameImpl(this._bp);
 
+  List<idl.UnlinkedPublicName> _constMembers;
+  idl.ReferenceKind _kind;
   String _name;
-  idl.ReferenceKind _kind;
   int _numTypeParameters;
-  List<idl.UnlinkedPublicName> _constMembers;
 
   @override
-  String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _name;
+  List<idl.UnlinkedPublicName> get constMembers {
+    _constMembers ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 0, const <idl.UnlinkedPublicName>[]);
+    return _constMembers;
   }
 
   @override
   idl.ReferenceKind get kind {
     _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, idl.ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
+    return _name;
+  }
+
+  @override
   int get numTypeParameters {
-    _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
+    _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
-
-  @override
-  List<idl.UnlinkedPublicName> get constMembers {
-    _constMembers ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 3, const <idl.UnlinkedPublicName>[]);
-    return _constMembers;
-  }
 }
 
 abstract class _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
   @override
   Map<String, Object> toMap() => {
+    "constMembers": constMembers,
+    "kind": kind,
     "name": name,
-    "kind": kind,
     "numTypeParameters": numTypeParameters,
-    "constMembers": constMembers,
   };
 }
 
 class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
   bool _finished = false;
 
+  List<UnlinkedExportPublicBuilder> _exports;
   List<UnlinkedPublicNameBuilder> _names;
-  List<UnlinkedExportPublicBuilder> _exports;
   List<String> _parts;
 
   @override
+  List<UnlinkedExportPublicBuilder> get exports => _exports ??= <UnlinkedExportPublicBuilder>[];
+
+  /**
+   * Export declarations in the compilation unit.
+   */
+  void set exports(List<UnlinkedExportPublicBuilder> _value) {
+    assert(!_finished);
+    _exports = _value;
+  }
+
+  @override
   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<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 ??= <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})
-    : _names = names,
-      _exports = exports,
+  UnlinkedPublicNamespaceBuilder({List<UnlinkedExportPublicBuilder> exports, List<UnlinkedPublicNameBuilder> names, List<String> parts})
+    : _exports = exports,
+      _names = names,
       _parts = parts;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_exports;
     fb.Offset offset_names;
-    fb.Offset offset_exports;
     fb.Offset offset_parts;
+    if (!(_exports == null || _exports.isEmpty)) {
+      offset_exports = fbBuilder.writeList(_exports.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_names == null || _names.isEmpty)) {
       offset_names = fbBuilder.writeList(_names.map((b) => b.finish(fbBuilder)).toList());
     }
-    if (!(_exports == null || _exports.isEmpty)) {
-      offset_exports = fbBuilder.writeList(_exports.map((b) => b.finish(fbBuilder)).toList());
-    }
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
+    if (offset_exports != null) {
+      fbBuilder.addOffset(0, offset_exports);
+    }
     if (offset_names != null) {
-      fbBuilder.addOffset(0, offset_names);
-    }
-    if (offset_exports != null) {
-      fbBuilder.addOffset(1, offset_exports);
+      fbBuilder.addOffset(1, offset_names);
     }
     if (offset_parts != null) {
       fbBuilder.addOffset(2, offset_parts);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.UnlinkedPublicNamespace readUnlinkedPublicNamespace(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _UnlinkedPublicNamespaceReader().read(rootRef);
 }
 
 class _UnlinkedPublicNamespaceReader extends fb.TableReader<_UnlinkedPublicNamespaceImpl> {
   const _UnlinkedPublicNamespaceReader();
 
   @override
   _UnlinkedPublicNamespaceImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNamespaceImpl(bp);
 }
 
 class _UnlinkedPublicNamespaceImpl extends Object with _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNamespaceImpl(this._bp);
 
+  List<idl.UnlinkedExportPublic> _exports;
   List<idl.UnlinkedPublicName> _names;
-  List<idl.UnlinkedExportPublic> _exports;
   List<String> _parts;
 
   @override
+  List<idl.UnlinkedExportPublic> get exports {
+    _exports ??= const fb.ListReader<idl.UnlinkedExportPublic>(const _UnlinkedExportPublicReader()).vTableGet(_bp, 0, const <idl.UnlinkedExportPublic>[]);
+    return _exports;
+  }
+
+  @override
   List<idl.UnlinkedPublicName> get names {
-    _names ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 0, const <idl.UnlinkedPublicName>[]);
+    _names ??= const fb.ListReader<idl.UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 1, const <idl.UnlinkedPublicName>[]);
     return _names;
   }
 
   @override
-  List<idl.UnlinkedExportPublic> get exports {
-    _exports ??= const fb.ListReader<idl.UnlinkedExportPublic>(const _UnlinkedExportPublicReader()).vTableGet(_bp, 1, const <idl.UnlinkedExportPublic>[]);
-    return _exports;
-  }
-
-  @override
   List<String> get parts {
     _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
     return _parts;
   }
 }
 
 abstract class _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
   @override
   Map<String, Object> toMap() => {
+    "exports": exports,
     "names": names,
-    "exports": exports,
     "parts": parts,
   };
 }
 
 class UnlinkedReferenceBuilder extends Object with _UnlinkedReferenceMixin implements idl.UnlinkedReference {
   bool _finished = false;
 
   String _name;
   int _prefixReference;
 
@@ skipping 80 matching lines @@
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "prefixReference": prefixReference,
   };
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
-  List<UnlinkedConstBuilder> _annotations;
+  List<UnlinkedParamBuilder> _parameters;
+  EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
-  EntityRefBuilder _returnType;
-  List<UnlinkedParamBuilder> _parameters;
+
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this typedef.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
+  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
   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);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
-  UnlinkedDocumentationCommentBuilder get documentationComment => _documentationComment;
+  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
-   * Documentation comment for the typedef, or `null` if there is no
-   * documentation comment.
+   * Parameters of the executable, if any.
    */
-  void set documentationComment(UnlinkedDocumentationCommentBuilder _value) {
+  void set parameters(List<UnlinkedParamBuilder> _value) {
     assert(!_finished);
-    _documentationComment = _value;
+    _parameters = _value;
   }
 
   @override
-  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * Annotations for this typedef.
-   */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _annotations = _value;
-  }
-
-  @override
-  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
-
-  /**
-   * Type parameters of the typedef, if any.
-   */
-  void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
-    assert(!_finished);
-    _typeParameters = _value;
-  }
-
-  @override
   EntityRefBuilder get returnType => _returnType;
 
   /**
    * Return type of the typedef.
    */
   void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
-  List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
+  List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
-   * Parameters of the executable, if any.
+   * Type parameters of the typedef, if any.
    */
-  void set parameters(List<UnlinkedParamBuilder> _value) {
+  void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
-    _parameters = _value;
+    _typeParameters = _value;
   }
 
-  UnlinkedTypedefBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters})
-    : _name = name,
+  UnlinkedTypedefBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
+    : _annotations = annotations,
+      _documentationComment = documentationComment,
+      _name = name,
       _nameOffset = nameOffset,
-      _documentationComment = documentationComment,
-      _annotations = annotations,
-      _typeParameters = typeParameters,
+      _parameters = parameters,
       _returnType = returnType,
-      _parameters = parameters;
+      _typeParameters = typeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_documentationComment;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
-    fb.Offset offset_annotations;
+    fb.Offset offset_parameters;
+    fb.Offset offset_returnType;
     fb.Offset offset_typeParameters;
-    fb.Offset offset_returnType;
-    fb.Offset offset_parameters;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
+    if (!(_parameters == null || _parameters.isEmpty)) {
+      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_returnType != null) {
+      offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
-    if (_returnType != null) {
-      offset_returnType = _returnType.finish(fbBuilder);
+    fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
     }
-    if (!(_parameters == null || _parameters.isEmpty)) {
-      offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
+    if (offset_documentationComment != null) {
+      fbBuilder.addOffset(1, offset_documentationComment);
     }
-    fbBuilder.startTable();
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+      fbBuilder.addOffset(2, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
+      fbBuilder.addUint32(3, _nameOffset);
     }
-    if (offset_documentationComment != null) {
-      fbBuilder.addOffset(2, offset_documentationComment);
-    }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
-    }
-    if (offset_typeParameters != null) {
-      fbBuilder.addOffset(4, offset_typeParameters);
+    if (offset_parameters != null) {
+      fbBuilder.addOffset(4, offset_parameters);
     }
     if (offset_returnType != null) {
       fbBuilder.addOffset(5, offset_returnType);
     }
-    if (offset_parameters != null) {
-      fbBuilder.addOffset(6, offset_parameters);
+    if (offset_typeParameters != null) {
+      fbBuilder.addOffset(6, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
   const _UnlinkedTypedefReader();
 
   @override
   _UnlinkedTypedefImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypedefImpl(bp);
 }
 
 class _UnlinkedTypedefImpl extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypedefImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.UnlinkedDocumentationComment _documentationComment;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
-  List<idl.UnlinkedConst> _annotations;
+  List<idl.UnlinkedParam> _parameters;
+  idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
-  idl.EntityRef _returnType;
-  List<idl.UnlinkedParam> _parameters;
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
+  idl.UnlinkedDocumentationComment get documentationComment {
+    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 1, null);
+    return _documentationComment;
+  }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _nameOffset;
   }
 
   @override
-  idl.UnlinkedDocumentationComment get documentationComment {
-    _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
-    return _documentationComment;
+  List<idl.UnlinkedParam> get parameters {
+    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedParam>[]);
+    return _parameters;
   }
 
   @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
-  }
-
-  @override
-  List<idl.UnlinkedTypeParam> get typeParameters {
-    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 4, const <idl.UnlinkedTypeParam>[]);
-    return _typeParameters;
-  }
-
-  @override
   idl.EntityRef get returnType {
     _returnType ??= const _EntityRefReader().vTableGet(_bp, 5, null);
     return _returnType;
   }
 
   @override
-  List<idl.UnlinkedParam> get parameters {
-    _parameters ??= const fb.ListReader<idl.UnlinkedParam>(const _UnlinkedParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedParam>[]);
-    return _parameters;
+  List<idl.UnlinkedTypeParam> get typeParameters {
+    _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bp, 6, const <idl.UnlinkedTypeParam>[]);
+    return _typeParameters;
   }
 }
 
 abstract class _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "annotations": annotations,
+    "parameters": parameters,
+    "returnType": returnType,
     "typeParameters": typeParameters,
-    "returnType": returnType,
-    "parameters": parameters,
   };
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  EntityRefBuilder _bound;
   String _name;
   int _nameOffset;
-  List<UnlinkedConstBuilder> _annotations;
-  EntityRefBuilder _bound;
+
+  @override
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for this type parameter.
+   */
+  void set annotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _annotations = _value;
+  }
+
+  @override
+  EntityRefBuilder get bound => _bound;
+
+  /**
+   * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
+   * null.
+   */
+  void set bound(EntityRefBuilder _value) {
+    assert(!_finished);
+    _bound = _value;
+  }
 
   @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);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
-  @override
-  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * Annotations for this type parameter.
-   */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _annotations = _value;
-  }
-
-  @override
-  EntityRefBuilder get bound => _bound;
-
-  /**
-   * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
-   * null.
-   */
-  void set bound(EntityRefBuilder _value) {
-    assert(!_finished);
-    _bound = _value;
-  }
-
-  UnlinkedTypeParamBuilder({String name, int nameOffset, List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound})
-    : _name = name,
-      _nameOffset = nameOffset,
-      _annotations = annotations,
-      _bound = bound;
+  UnlinkedTypeParamBuilder({List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound, String name, int nameOffset})
+    : _annotations = annotations,
+      _bound = bound,
+      _name = name,
+      _nameOffset = nameOffset;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
-    fb.Offset offset_name;
     fb.Offset offset_annotations;
     fb.Offset offset_bound;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
-    }
+    fb.Offset offset_name;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_bound != null) {
       offset_bound = _bound.finish(fbBuilder);
     }
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
     fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
+    }
+    if (offset_bound != null) {
+      fbBuilder.addOffset(1, offset_bound);
+    }
     if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
+      fbBuilder.addOffset(2, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
-    }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(2, offset_annotations);
-    }
-    if (offset_bound != null) {
-      fbBuilder.addOffset(3, offset_bound);
+      fbBuilder.addUint32(3, _nameOffset);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedTypeParamReader extends fb.TableReader<_UnlinkedTypeParamImpl> {
   const _UnlinkedTypeParamReader();
 
   @override
   _UnlinkedTypeParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedTypeParamImpl(bp);
 }
 
 class _UnlinkedTypeParamImpl extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedTypeParamImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.EntityRef _bound;
   String _name;
   int _nameOffset;
-  List<idl.UnlinkedConst> _annotations;
-  idl.EntityRef _bound;
+
+  @override
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
+  }
+
+  @override
+  idl.EntityRef get bound {
+    _bound ??= const _EntityRefReader().vTableGet(_bp, 1, null);
+    return _bound;
+  }
 
   @override
   String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _name ??= const fb.StringReader().vTableGet(_bp, 2, '');
     return _name;
   }
 
   @override
   int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
     return _nameOffset;
   }
-
-  @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 2, const <idl.UnlinkedConst>[]);
-    return _annotations;
-  }
-
-  @override
-  idl.EntityRef get bound {
-    _bound ??= const _EntityRefReader().vTableGet(_bp, 3, null);
-    return _bound;
-  }
 }
 
 abstract class _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "bound": bound,
     "name": name,
     "nameOffset": nameOffset,
-    "annotations": annotations,
-    "bound": bound,
   };
 }
 
 class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   bool _finished = false;
 
-  String _libraryName;
-  int _libraryNameOffset;
-  int _libraryNameLength;
-  UnlinkedDocumentationCommentBuilder _libraryDocumentationComment;
-  List<UnlinkedConstBuilder> _libraryAnnotations;
-  UnlinkedPublicNamespaceBuilder _publicNamespace;
-  List<UnlinkedReferenceBuilder> _references;
   List<UnlinkedClassBuilder> _classes;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
   List<UnlinkedImportBuilder> _imports;
+  List<UnlinkedConstBuilder> _libraryAnnotations;
+  UnlinkedDocumentationCommentBuilder _libraryDocumentationComment;
+  String _libraryName;
+  int _libraryNameLength;
+  int _libraryNameOffset;
   List<UnlinkedPartBuilder> _parts;
+  UnlinkedPublicNamespaceBuilder _publicNamespace;
+  List<UnlinkedReferenceBuilder> _references;
   List<UnlinkedTypedefBuilder> _typedefs;
   List<UnlinkedVariableBuilder> _variables;
 
   @override
+  List<UnlinkedClassBuilder> get classes => _classes ??= <UnlinkedClassBuilder>[];
+
+  /**
+   * Classes declared in the compilation unit.
+   */
+  void set classes(List<UnlinkedClassBuilder> _value) {
+    assert(!_finished);
+    _classes = _value;
+  }
+
+  @override
+  List<UnlinkedEnumBuilder> get enums => _enums ??= <UnlinkedEnumBuilder>[];
+
+  /**
+   * Enums declared in the compilation unit.
+   */
+  void set enums(List<UnlinkedEnumBuilder> _value) {
+    assert(!_finished);
+    _enums = _value;
+  }
+
+  @override
+  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<UnlinkedExportNonPublicBuilder> get exports => _exports ??= <UnlinkedExportNonPublicBuilder>[];
+
+  /**
+   * Export declarations in the compilation unit.
+   */
+  void set exports(List<UnlinkedExportNonPublicBuilder> _value) {
+    assert(!_finished);
+    _exports = _value;
+  }
+
+  @override
+  List<UnlinkedImportBuilder> get imports => _imports ??= <UnlinkedImportBuilder>[];
+
+  /**
+   * Import declarations in the compilation unit.
+   */
+  void set imports(List<UnlinkedImportBuilder> _value) {
+    assert(!_finished);
+    _imports = _value;
+  }
+
+  @override
+  List<UnlinkedConstBuilder> get libraryAnnotations => _libraryAnnotations ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * Annotations for the library declaration, or the empty list if there is no
+   * library declaration.
+   */
+  void set libraryAnnotations(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _libraryAnnotations = _value;
+  }
+
+  @override
+  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
   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 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
   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;
-
-  /**
-   * 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
-  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
-  List<UnlinkedConstBuilder> get libraryAnnotations => _libraryAnnotations ??= <UnlinkedConstBuilder>[];
-
-  /**
-   * Annotations for the library declaration, or the empty list if there is no
-   * library declaration.
-   */
-  void set libraryAnnotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
-    _libraryAnnotations = _value;
+  List<UnlinkedPartBuilder> get parts => _parts ??= <UnlinkedPartBuilder>[];
+
+  /**
+   * Part declarations in the compilation unit.
+   */
+  void set parts(List<UnlinkedPartBuilder> _value) {
+    assert(!_finished);
+    _parts = _value;
   }
 
   @override
   UnlinkedPublicNamespaceBuilder get publicNamespace => _publicNamespace;
 
   /**
    * Unlinked public namespace of this compilation unit.
    */
   void set publicNamespace(UnlinkedPublicNamespaceBuilder _value) {
     assert(!_finished);
     _publicNamespace = _value;
   }
 
   @override
   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 is used to represent
    * the absence of a reference in places where a reference is optional (for
    * example [UnlinkedReference.prefixReference or
    * UnlinkedImport.prefixReference]).
    */
   void set references(List<UnlinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
   @override
-  List<UnlinkedClassBuilder> get classes => _classes ??= <UnlinkedClassBuilder>[];
-
-  /**
-   * Classes declared in the compilation unit.
-   */
-  void set classes(List<UnlinkedClassBuilder> _value) {
-    assert(!_finished);
-    _classes = _value;
-  }
-
-  @override
-  List<UnlinkedEnumBuilder> get enums => _enums ??= <UnlinkedEnumBuilder>[];
-
-  /**
-   * Enums declared in the compilation unit.
-   */
-  void set enums(List<UnlinkedEnumBuilder> _value) {
-    assert(!_finished);
-    _enums = _value;
-  }
-
-  @override
-  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<UnlinkedExportNonPublicBuilder> get exports => _exports ??= <UnlinkedExportNonPublicBuilder>[];
-
-  /**
-   * Export declarations in the compilation unit.
-   */
-  void set exports(List<UnlinkedExportNonPublicBuilder> _value) {
-    assert(!_finished);
-    _exports = _value;
-  }
-
-  @override
-  List<UnlinkedImportBuilder> get imports => _imports ??= <UnlinkedImportBuilder>[];
-
-  /**
-   * Import declarations in the compilation unit.
-   */
-  void set imports(List<UnlinkedImportBuilder> _value) {
-    assert(!_finished);
-    _imports = _value;
-  }
-
-  @override
-  List<UnlinkedPartBuilder> get parts => _parts ??= <UnlinkedPartBuilder>[];
-
-  /**
-   * Part declarations in the compilation unit.
-   */
-  void set parts(List<UnlinkedPartBuilder> _value) {
-    assert(!_finished);
-    _parts = _value;
-  }
-
-  @override
   List<UnlinkedTypedefBuilder> get typedefs => _typedefs ??= <UnlinkedTypedefBuilder>[];
 
   /**
    * Typedefs declared in the compilation unit.
    */
   void set typedefs(List<UnlinkedTypedefBuilder> _value) {
     assert(!_finished);
     _typedefs = _value;
   }
 
   @override
   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, List<UnlinkedConstBuilder> libraryAnnotations, 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})
-    : _libraryName = libraryName,
-      _libraryNameOffset = libraryNameOffset,
-      _libraryNameLength = libraryNameLength,
-      _libraryDocumentationComment = libraryDocumentationComment,
-      _libraryAnnotations = libraryAnnotations,
-      _publicNamespace = publicNamespace,
-      _references = references,
-      _classes = classes,
+  UnlinkedUnitBuilder({List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, String libraryName, int libraryNameLength, int libraryNameOffset, List<UnlinkedPartBuilder> parts, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
+    : _classes = classes,
       _enums = enums,
       _executables = executables,
       _exports = exports,
       _imports = imports,
+      _libraryAnnotations = libraryAnnotations,
+      _libraryDocumentationComment = libraryDocumentationComment,
+      _libraryName = libraryName,
+      _libraryNameLength = libraryNameLength,
+      _libraryNameOffset = libraryNameOffset,
       _parts = parts,
+      _publicNamespace = publicNamespace,
+      _references = references,
       _typedefs = typedefs,
       _variables = variables;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
-    fb.Offset offset_libraryName;
-    fb.Offset offset_libraryDocumentationComment;
-    fb.Offset offset_libraryAnnotations;
-    fb.Offset offset_publicNamespace;
-    fb.Offset offset_references;
     fb.Offset offset_classes;
     fb.Offset offset_enums;
     fb.Offset offset_executables;
     fb.Offset offset_exports;
     fb.Offset offset_imports;
+    fb.Offset offset_libraryAnnotations;
+    fb.Offset offset_libraryDocumentationComment;
+    fb.Offset offset_libraryName;
     fb.Offset offset_parts;
+    fb.Offset offset_publicNamespace;
+    fb.Offset offset_references;
     fb.Offset offset_typedefs;
     fb.Offset offset_variables;
-    if (_libraryName != null) {
-      offset_libraryName = fbBuilder.writeString(_libraryName);
-    }
-    if (_libraryDocumentationComment != null) {
-      offset_libraryDocumentationComment = _libraryDocumentationComment.finish(fbBuilder);
-    }
-    if (!(_libraryAnnotations == null || _libraryAnnotations.isEmpty)) {
-      offset_libraryAnnotations = fbBuilder.writeList(_libraryAnnotations.map((b) => b.finish(fbBuilder)).toList());
-    }
-    if (_publicNamespace != null) {
-      offset_publicNamespace = _publicNamespace.finish(fbBuilder);
-    }
-    if (!(_references == null || _references.isEmpty)) {
-      offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
-    }
     if (!(_classes == null || _classes.isEmpty)) {
       offset_classes = fbBuilder.writeList(_classes.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_enums == null || _enums.isEmpty)) {
       offset_enums = fbBuilder.writeList(_enums.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_executables == null || _executables.isEmpty)) {
       offset_executables = fbBuilder.writeList(_executables.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_exports == null || _exports.isEmpty)) {
       offset_exports = fbBuilder.writeList(_exports.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_imports == null || _imports.isEmpty)) {
       offset_imports = fbBuilder.writeList(_imports.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_libraryAnnotations == null || _libraryAnnotations.isEmpty)) {
+      offset_libraryAnnotations = fbBuilder.writeList(_libraryAnnotations.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_libraryDocumentationComment != null) {
+      offset_libraryDocumentationComment = _libraryDocumentationComment.finish(fbBuilder);
+    }
+    if (_libraryName != null) {
+      offset_libraryName = fbBuilder.writeString(_libraryName);
+    }
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (_publicNamespace != null) {
+      offset_publicNamespace = _publicNamespace.finish(fbBuilder);
+    }
+    if (!(_references == null || _references.isEmpty)) {
+      offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_typedefs == null || _typedefs.isEmpty)) {
       offset_typedefs = fbBuilder.writeList(_typedefs.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_variables == null || _variables.isEmpty)) {
       offset_variables = fbBuilder.writeList(_variables.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (offset_classes != null) {
+      fbBuilder.addOffset(0, offset_classes);
+    }
+    if (offset_enums != null) {
+      fbBuilder.addOffset(1, offset_enums);
+    }
+    if (offset_executables != null) {
+      fbBuilder.addOffset(2, offset_executables);
+    }
+    if (offset_exports != null) {
+      fbBuilder.addOffset(3, offset_exports);
+    }
+    if (offset_imports != null) {
+      fbBuilder.addOffset(4, offset_imports);
+    }
+    if (offset_libraryAnnotations != null) {
+      fbBuilder.addOffset(5, offset_libraryAnnotations);
+    }
+    if (offset_libraryDocumentationComment != null) {
+      fbBuilder.addOffset(6, offset_libraryDocumentationComment);
+    }
     if (offset_libraryName != null) {
-      fbBuilder.addOffset(0, offset_libraryName);
+      fbBuilder.addOffset(7, offset_libraryName);
+    }
+    if (_libraryNameLength != null && _libraryNameLength != 0) {
+      fbBuilder.addUint32(8, _libraryNameLength);
     }
     if (_libraryNameOffset != null && _libraryNameOffset != 0) {
-      fbBuilder.addUint32(1, _libraryNameOffset);
+      fbBuilder.addUint32(9, _libraryNameOffset);
     }
-    if (_libraryNameLength != null && _libraryNameLength != 0) {
-      fbBuilder.addUint32(2, _libraryNameLength);
-    }
-    if (offset_libraryDocumentationComment != null) {
-      fbBuilder.addOffset(3, offset_libraryDocumentationComment);
-    }
-    if (offset_libraryAnnotations != null) {
-      fbBuilder.addOffset(4, offset_libraryAnnotations);
+    if (offset_parts != null) {
+      fbBuilder.addOffset(10, offset_parts);
     }
     if (offset_publicNamespace != null) {
-      fbBuilder.addOffset(5, offset_publicNamespace);
+      fbBuilder.addOffset(11, offset_publicNamespace);
     }
     if (offset_references != null) {
-      fbBuilder.addOffset(6, offset_references);
-    }
-    if (offset_classes != null) {
-      fbBuilder.addOffset(7, offset_classes);
-    }
-    if (offset_enums != null) {
-      fbBuilder.addOffset(8, offset_enums);
-    }
-    if (offset_executables != null) {
-      fbBuilder.addOffset(9, offset_executables);
-    }
-    if (offset_exports != null) {
-      fbBuilder.addOffset(10, offset_exports);
-    }
-    if (offset_imports != null) {
-      fbBuilder.addOffset(11, offset_imports);
-    }
-    if (offset_parts != null) {
-      fbBuilder.addOffset(12, offset_parts);
+      fbBuilder.addOffset(12, offset_references);
     }
     if (offset_typedefs != null) {
       fbBuilder.addOffset(13, offset_typedefs);
     }
     if (offset_variables != null) {
       fbBuilder.addOffset(14, offset_variables);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.UnlinkedUnit readUnlinkedUnit(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _UnlinkedUnitReader().read(rootRef);
 }
 
 class _UnlinkedUnitReader extends fb.TableReader<_UnlinkedUnitImpl> {
   const _UnlinkedUnitReader();
 
   @override
   _UnlinkedUnitImpl createObject(fb.BufferPointer bp) => new _UnlinkedUnitImpl(bp);
 }
 
 class _UnlinkedUnitImpl extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   final fb.BufferPointer _bp;
 
   _UnlinkedUnitImpl(this._bp);
 
-  String _libraryName;
-  int _libraryNameOffset;
-  int _libraryNameLength;
-  idl.UnlinkedDocumentationComment _libraryDocumentationComment;
-  List<idl.UnlinkedConst> _libraryAnnotations;
-  idl.UnlinkedPublicNamespace _publicNamespace;
-  List<idl.UnlinkedReference> _references;
   List<idl.UnlinkedClass> _classes;
   List<idl.UnlinkedEnum> _enums;
   List<idl.UnlinkedExecutable> _executables;
   List<idl.UnlinkedExportNonPublic> _exports;
   List<idl.UnlinkedImport> _imports;
+  List<idl.UnlinkedConst> _libraryAnnotations;
+  idl.UnlinkedDocumentationComment _libraryDocumentationComment;
+  String _libraryName;
+  int _libraryNameLength;
+  int _libraryNameOffset;
   List<idl.UnlinkedPart> _parts;
+  idl.UnlinkedPublicNamespace _publicNamespace;
+  List<idl.UnlinkedReference> _references;
   List<idl.UnlinkedTypedef> _typedefs;
   List<idl.UnlinkedVariable> _variables;
 
   @override
+  List<idl.UnlinkedClass> get classes {
+    _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 0, const <idl.UnlinkedClass>[]);
+    return _classes;
+  }
+
+  @override
+  List<idl.UnlinkedEnum> get enums {
+    _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 1, const <idl.UnlinkedEnum>[]);
+    return _enums;
+  }
+
+  @override
+  List<idl.UnlinkedExecutable> get executables {
+    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 2, const <idl.UnlinkedExecutable>[]);
+    return _executables;
+  }
+
+  @override
+  List<idl.UnlinkedExportNonPublic> get exports {
+    _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 3, const <idl.UnlinkedExportNonPublic>[]);
+    return _exports;
+  }
+
+  @override
+  List<idl.UnlinkedImport> get imports {
+    _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 4, const <idl.UnlinkedImport>[]);
+    return _imports;
+  }
+
+  @override
+  List<idl.UnlinkedConst> get libraryAnnotations {
+    _libraryAnnotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 5, const <idl.UnlinkedConst>[]);
+    return _libraryAnnotations;
+  }
+
+  @override
+  idl.UnlinkedDocumentationComment get libraryDocumentationComment {
+    _libraryDocumentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 6, null);
+    return _libraryDocumentationComment;
+  }
+
+  @override
   String get libraryName {
-    _libraryName ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    _libraryName ??= const fb.StringReader().vTableGet(_bp, 7, '');
     return _libraryName;
   }
 
   @override
+  int get libraryNameLength {
+    _libraryNameLength ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    return _libraryNameLength;
+  }
+
+  @override
   int get libraryNameOffset {
-    _libraryNameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
+    _libraryNameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _libraryNameOffset;
   }
 
   @override
-  int get libraryNameLength {
-    _libraryNameLength ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
-    return _libraryNameLength;
-  }
-
-  @override
-  idl.UnlinkedDocumentationComment get libraryDocumentationComment {
-    _libraryDocumentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 3, null);
-    return _libraryDocumentationComment;
-  }
-
-  @override
-  List<idl.UnlinkedConst> get libraryAnnotations {
-    _libraryAnnotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 4, const <idl.UnlinkedConst>[]);
-    return _libraryAnnotations;
+  List<idl.UnlinkedPart> get parts {
+    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 10, const <idl.UnlinkedPart>[]);
+    return _parts;
   }
 
   @override
   idl.UnlinkedPublicNamespace get publicNamespace {
-    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 5, null);
+    _publicNamespace ??= const _UnlinkedPublicNamespaceReader().vTableGet(_bp, 11, null);
     return _publicNamespace;
   }
 
   @override
   List<idl.UnlinkedReference> get references {
-    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 6, const <idl.UnlinkedReference>[]);
+    _references ??= const fb.ListReader<idl.UnlinkedReference>(const _UnlinkedReferenceReader()).vTableGet(_bp, 12, const <idl.UnlinkedReference>[]);
     return _references;
   }
 
   @override
-  List<idl.UnlinkedClass> get classes {
-    _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 7, const <idl.UnlinkedClass>[]);
-    return _classes;
-  }
-
-  @override
-  List<idl.UnlinkedEnum> get enums {
-    _enums ??= const fb.ListReader<idl.UnlinkedEnum>(const _UnlinkedEnumReader()).vTableGet(_bp, 8, const <idl.UnlinkedEnum>[]);
-    return _enums;
-  }
-
-  @override
-  List<idl.UnlinkedExecutable> get executables {
-    _executables ??= const fb.ListReader<idl.UnlinkedExecutable>(const _UnlinkedExecutableReader()).vTableGet(_bp, 9, const <idl.UnlinkedExecutable>[]);
-    return _executables;
-  }
-
-  @override
-  List<idl.UnlinkedExportNonPublic> get exports {
-    _exports ??= const fb.ListReader<idl.UnlinkedExportNonPublic>(const _UnlinkedExportNonPublicReader()).vTableGet(_bp, 10, const <idl.UnlinkedExportNonPublic>[]);
-    return _exports;
-  }
-
-  @override
-  List<idl.UnlinkedImport> get imports {
-    _imports ??= const fb.ListReader<idl.UnlinkedImport>(const _UnlinkedImportReader()).vTableGet(_bp, 11, const <idl.UnlinkedImport>[]);
-    return _imports;
-  }
-
-  @override
-  List<idl.UnlinkedPart> get parts {
-    _parts ??= const fb.ListReader<idl.UnlinkedPart>(const _UnlinkedPartReader()).vTableGet(_bp, 12, const <idl.UnlinkedPart>[]);
-    return _parts;
-  }
-
-  @override
   List<idl.UnlinkedTypedef> get typedefs {
     _typedefs ??= const fb.ListReader<idl.UnlinkedTypedef>(const _UnlinkedTypedefReader()).vTableGet(_bp, 13, const <idl.UnlinkedTypedef>[]);
     return _typedefs;
   }
 
   @override
   List<idl.UnlinkedVariable> get variables {
     _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 14, const <idl.UnlinkedVariable>[]);
     return _variables;
   }
 }
 
 abstract class _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   @override
   Map<String, Object> toMap() => {
-    "libraryName": libraryName,
-    "libraryNameOffset": libraryNameOffset,
-    "libraryNameLength": libraryNameLength,
-    "libraryDocumentationComment": libraryDocumentationComment,
-    "libraryAnnotations": libraryAnnotations,
-    "publicNamespace": publicNamespace,
-    "references": references,
     "classes": classes,
     "enums": enums,
     "executables": executables,
     "exports": exports,
     "imports": imports,
+    "libraryAnnotations": libraryAnnotations,
+    "libraryDocumentationComment": libraryDocumentationComment,
+    "libraryName": libraryName,
+    "libraryNameLength": libraryNameLength,
+    "libraryNameOffset": libraryNameOffset,
     "parts": parts,
+    "publicNamespace": publicNamespace,
+    "references": references,
     "typedefs": typedefs,
     "variables": variables,
   };
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   bool _finished = false;
 
+  List<UnlinkedConstBuilder> _annotations;
+  UnlinkedConstBuilder _constExpr;
+  UnlinkedDocumentationCommentBuilder _documentationComment;
+  int _inferredTypeSlot;
+  bool _isConst;
+  bool _isFinal;
+  bool _isStatic;
   String _name;
   int _nameOffset;
-  UnlinkedDocumentationCommentBuilder _documentationComment;
-  List<UnlinkedConstBuilder> _annotations;
+  int _propagatedTypeSlot;
   EntityRefBuilder _type;
-  UnlinkedConstBuilder _constExpr;
-  bool _isStatic;
-  bool _isFinal;
-  bool _isConst;
-  int _propagatedTypeSlot;
-  int _inferredTypeSlot;
 
   @override
-  String get name => _name ??= '';
+  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
-   * Name of the variable.
+   * Annotations for this variable.
    */
-  void set name(String _value) {
+  void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
-    _name = _value;
+    _annotations = _value;
   }
 
   @override
-  int get nameOffset => _nameOffset ??= 0;
+  UnlinkedConstBuilder get constExpr => _constExpr;
 
   /**
-   * Offset of the variable name relative to the beginning of the file.
+   * If [isConst] is true, and the variable has an initializer, the constant
+   * expression in the initializer.  Note that the presence of this expression
+   * does not mean that it is a valid, check [UnlinkedConst.isInvalid].
    */
-  void set nameOffset(int _value) {
+  void set constExpr(UnlinkedConstBuilder _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _nameOffset = _value;
+    _constExpr = _value;
   }
 
   @override
   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
-  List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
+  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
-   * Annotations for this variable.
+   * If this variable is inferable, nonzero slot id identifying which entry in
+   * [LinkedLibrary.types] contains the inferred type for this variable.  If
+   * there is no matching entry in [LinkedLibrary.types], then no type was
+   * inferred for this variable, so its static type is `dynamic`.
    */
-  void set annotations(List<UnlinkedConstBuilder> _value) {
+  void set inferredTypeSlot(int _value) {
     assert(!_finished);
-    _annotations = _value;
+    assert(_value == null || _value >= 0);
+    _inferredTypeSlot = _value;
   }
 
   @override
-  EntityRefBuilder get type => _type;
+  bool get isConst => _isConst ??= false;
 
   /**
-   * Declared type of the variable.  Absent if the type is implicit.
+   * Indicates whether the variable is declared using the `const` keyword.
    */
-  void set type(EntityRefBuilder _value) {
+  void set isConst(bool _value) {
     assert(!_finished);
-    _type = _value;
+    _isConst = _value;
   }
 
   @override
-  UnlinkedConstBuilder get constExpr => _constExpr;
+  bool get isFinal => _isFinal ??= false;
 
   /**
-   * If [isConst] is true, and the variable has an initializer, the constant
-   * expression in the initializer.  Note that the presence of this expression
-   * does not mean that it is a valid, check [UnlinkedConst.isInvalid].
+   * Indicates whether the variable is declared using the `final` keyword.
    */
-  void set constExpr(UnlinkedConstBuilder _value) {
+  void set isFinal(bool _value) {
     assert(!_finished);
-    _constExpr = _value;
+    _isFinal = _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;
+  String get name => _name ??= '';
 
   /**
-   * Indicates whether the variable is declared using the `final` keyword.
+   * Name of the variable.
    */
-  void set isFinal(bool _value) {
+  void set name(String _value) {
     assert(!_finished);
-    _isFinal = _value;
+    _name = _value;
   }
 
   @override
-  bool get isConst => _isConst ??= false;
+  int get nameOffset => _nameOffset ??= 0;
 
   /**
-   * Indicates whether the variable is declared using the `const` keyword.
+   * Offset of the variable name relative to the beginning of the file.
    */
-  void set isConst(bool _value) {
+  void set nameOffset(int _value) {
     assert(!_finished);
-    _isConst = _value;
+    assert(_value == null || _value >= 0);
+    _nameOffset = _value;
   }
 
   @override
   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) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _propagatedTypeSlot = _value;
   }
 
   @override
-  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
+  EntityRefBuilder get type => _type;
 
   /**
-   * If this variable is inferable, nonzero slot id identifying which entry in
-   * [LinkedLibrary.types] contains the inferred type for this variable.  If
-   * there is no matching entry in [LinkedLibrary.types], then no type was
-   * inferred for this variable, so its static type is `dynamic`.
+   * Declared type of the variable.  Absent if the type is implicit.
    */
-  void set inferredTypeSlot(int _value) {
+  void set type(EntityRefBuilder _value) {
     assert(!_finished);
-    assert(_value == null || _value >= 0);
-    _inferredTypeSlot = _value;
+    _type = _value;
   }
 
-  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, EntityRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, int propagatedTypeSlot, int inferredTypeSlot})
-    : _name = name,
+  UnlinkedVariableBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedConstBuilder constExpr, UnlinkedDocumentationCommentBuilder documentationComment, int inferredTypeSlot, bool isConst, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type})
+    : _annotations = annotations,
+      _constExpr = constExpr,
+      _documentationComment = documentationComment,
+      _inferredTypeSlot = inferredTypeSlot,
+      _isConst = isConst,
+      _isFinal = isFinal,
+      _isStatic = isStatic,
+      _name = name,
       _nameOffset = nameOffset,
-      _documentationComment = documentationComment,
-      _annotations = annotations,
-      _type = type,
-      _constExpr = constExpr,
-      _isStatic = isStatic,
-      _isFinal = isFinal,
-      _isConst = isConst,
       _propagatedTypeSlot = propagatedTypeSlot,
-      _inferredTypeSlot = inferredTypeSlot;
+      _type = type;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_annotations;
+    fb.Offset offset_constExpr;
+    fb.Offset offset_documentationComment;
     fb.Offset offset_name;
-    fb.Offset offset_documentationComment;
-    fb.Offset offset_annotations;
     fb.Offset offset_type;
-    fb.Offset offset_constExpr;
-    if (_name != null) {
-      offset_name = fbBuilder.writeString(_name);
+    if (!(_annotations == null || _annotations.isEmpty)) {
+      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    }
+    if (_constExpr != null) {
+      offset_constExpr = _constExpr.finish(fbBuilder);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
-    if (!(_annotations == null || _annotations.isEmpty)) {
-      offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
-    if (_constExpr != null) {
-      offset_constExpr = _constExpr.finish(fbBuilder);
+    fbBuilder.startTable();
+    if (offset_annotations != null) {
+      fbBuilder.addOffset(0, offset_annotations);
     }
-    fbBuilder.startTable();
-    if (offset_name != null) {
-      fbBuilder.addOffset(0, offset_name);
-    }
-    if (_nameOffset != null && _nameOffset != 0) {
-      fbBuilder.addUint32(1, _nameOffset);
+    if (offset_constExpr != null) {
+      fbBuilder.addOffset(1, offset_constExpr);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
-    if (offset_annotations != null) {
-      fbBuilder.addOffset(3, offset_annotations);
+    if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
+      fbBuilder.addUint32(3, _inferredTypeSlot);
     }
-    if (offset_type != null) {
-      fbBuilder.addOffset(4, offset_type);
+    if (_isConst == true) {
+      fbBuilder.addBool(4, true);
     }
-    if (offset_constExpr != null) {
-      fbBuilder.addOffset(5, offset_constExpr);
+    if (_isFinal == true) {
+      fbBuilder.addBool(5, true);
     }
     if (_isStatic == true) {
       fbBuilder.addBool(6, true);
     }
-    if (_isFinal == true) {
-      fbBuilder.addBool(7, true);
+    if (offset_name != null) {
+      fbBuilder.addOffset(7, offset_name);
     }
-    if (_isConst == true) {
-      fbBuilder.addBool(8, true);
+    if (_nameOffset != null && _nameOffset != 0) {
+      fbBuilder.addUint32(8, _nameOffset);
     }
     if (_propagatedTypeSlot != null && _propagatedTypeSlot != 0) {
       fbBuilder.addUint32(9, _propagatedTypeSlot);
     }
-    if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
-      fbBuilder.addUint32(10, _inferredTypeSlot);
+    if (offset_type != null) {
+      fbBuilder.addOffset(10, offset_type);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
 }
 
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
+  List<idl.UnlinkedConst> _annotations;
+  idl.UnlinkedConst _constExpr;
+  idl.UnlinkedDocumentationComment _documentationComment;
+  int _inferredTypeSlot;
+  bool _isConst;
+  bool _isFinal;
+  bool _isStatic;
   String _name;
   int _nameOffset;
-  idl.UnlinkedDocumentationComment _documentationComment;
-  List<idl.UnlinkedConst> _annotations;
+  int _propagatedTypeSlot;
   idl.EntityRef _type;
-  idl.UnlinkedConst _constExpr;
-  bool _isStatic;
-  bool _isFinal;
-  bool _isConst;
-  int _propagatedTypeSlot;
-  int _inferredTypeSlot;
 
   @override
-  String get name {
-    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
-    return _name;
+  List<idl.UnlinkedConst> get annotations {
+    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 0, const <idl.UnlinkedConst>[]);
+    return _annotations;
   }
 
   @override
-  int get nameOffset {
-    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
-    return _nameOffset;
+  idl.UnlinkedConst get constExpr {
+    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
+    return _constExpr;
   }
 
   @override
   idl.UnlinkedDocumentationComment get documentationComment {
     _documentationComment ??= const _UnlinkedDocumentationCommentReader().vTableGet(_bp, 2, null);
     return _documentationComment;
   }
 
   @override
-  List<idl.UnlinkedConst> get annotations {
-    _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
-    return _annotations;
+  int get inferredTypeSlot {
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 3, 0);
+    return _inferredTypeSlot;
   }
 
   @override
-  idl.EntityRef get type {
-    _type ??= const _EntityRefReader().vTableGet(_bp, 4, null);
-    return _type;
+  bool get isConst {
+    _isConst ??= const fb.BoolReader().vTableGet(_bp, 4, false);
+    return _isConst;
   }
 
   @override
-  idl.UnlinkedConst get constExpr {
-    _constExpr ??= const _UnlinkedConstReader().vTableGet(_bp, 5, null);
-    return _constExpr;
+  bool get isFinal {
+    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    return _isFinal;
   }
 
   @override
   bool get isStatic {
     _isStatic ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isStatic;
   }
 
   @override
-  bool get isFinal {
-    _isFinal ??= const fb.BoolReader().vTableGet(_bp, 7, false);
-    return _isFinal;
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    return _name;
   }
 
   @override
-  bool get isConst {
-    _isConst ??= const fb.BoolReader().vTableGet(_bp, 8, false);
-    return _isConst;
+  int get nameOffset {
+    _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
+    return _nameOffset;
   }
 
   @override
   int get propagatedTypeSlot {
     _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
     return _propagatedTypeSlot;
   }
 
   @override
-  int get inferredTypeSlot {
-    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 10, 0);
-    return _inferredTypeSlot;
+  idl.EntityRef get type {
+    _type ??= const _EntityRefReader().vTableGet(_bp, 10, null);
+    return _type;
   }
 }
 
 abstract class _UnlinkedVariableMixin implements idl.UnlinkedVariable {
   @override
   Map<String, Object> toMap() => {
+    "annotations": annotations,
+    "constExpr": constExpr,
+    "documentationComment": documentationComment,
+    "inferredTypeSlot": inferredTypeSlot,
+    "isConst": isConst,
+    "isFinal": isFinal,
+    "isStatic": isStatic,
     "name": name,
     "nameOffset": nameOffset,
-    "documentationComment": documentationComment,
-    "annotations": annotations,
+    "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
-    "constExpr": constExpr,
-    "isStatic": isStatic,
-    "isFinal": isFinal,
-    "isConst": isConst,
-    "propagatedTypeSlot": propagatedTypeSlot,
-    "inferredTypeSlot": inferredTypeSlot,
   };
 }