Remove "_finished" assertion checks from summary codegen.

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 124 matching lines @@
   int get size => 1;
 
   @override
   idl.UnlinkedParamKind read(fb.BufferContext bc, int offset) {
     int index = const fb.Uint8Reader().read(bc, offset);
     return index < idl.UnlinkedParamKind.values.length ? idl.UnlinkedParamKind.values[index] : idl.UnlinkedParamKind.required;
   }
 }
 
 class CacheAnalysisErrorBuilder extends Object with _CacheAnalysisErrorMixin implements idl.CacheAnalysisError {
-  bool _finished = false;
-
   String _correction;
   String _errorCodeUniqueName;
   int _length;
   String _message;
   int _offset;
 
   @override
   String get correction => _correction ??= '';
 
   /**
    * The correction to be displayed for this error, or `null` if there is no
    * correction information for this error. The correction should indicate how
    * the user can fix the error.
    */
   void set correction(String _value) {
-    assert(!_finished);
     _correction = _value;
   }
 
   @override
   String get errorCodeUniqueName => _errorCodeUniqueName ??= '';
 
   /**
    * The unique name of the error code.
    */
   void set errorCodeUniqueName(String _value) {
-    assert(!_finished);
     _errorCodeUniqueName = _value;
   }
 
   @override
   int get length => _length ??= 0;
 
   /**
    * Length of the error range.
    */
   void set length(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _length = _value;
   }
 
   @override
   String get message => _message ??= '';
 
   /**
    * The message to be displayed for this error. The message should indicate
    * what is wrong and why it is wrong.
    */
   void set message(String _value) {
-    assert(!_finished);
     _message = _value;
   }
 
   @override
   int get offset => _offset ??= 0;
 
   /**
    * Offset of the error range relative to the beginning of the file.
    */
   void set offset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   CacheAnalysisErrorBuilder({String correction, String errorCodeUniqueName, int length, String message, int offset})
     : _correction = correction,
       _errorCodeUniqueName = errorCodeUniqueName,
       _length = length,
       _message = message,
       _offset = offset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_correction;
     fb.Offset offset_errorCodeUniqueName;
     fb.Offset offset_message;
     if (_correction != null) {
       offset_correction = fbBuilder.writeString(_correction);
     }
     if (_errorCodeUniqueName != null) {
       offset_errorCodeUniqueName = fbBuilder.writeString(_errorCodeUniqueName);
     }
     if (_message != null) {
@@ skipping 88 matching lines @@
     "length": length,
     "message": message,
     "offset": offset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class CacheSourceContentBuilder extends Object with _CacheSourceContentMixin implements idl.CacheSourceContent {
-  bool _finished = false;
-
   List<String> _exportedUris;
   List<String> _importedUris;
   idl.CacheSourceKind _kind;
   List<String> _partUris;
 
   @override
   List<String> get exportedUris => _exportedUris ??= <String>[];
 
   /**
    * The list of exported URIs, e.g. `dart:core`, or `foo/bar.dart`,
    * or `package:foo/bar.dart`.  Empty if [kind] is [CacheSourceKind.part].
    */
   void set exportedUris(List<String> _value) {
-    assert(!_finished);
     _exportedUris = _value;
   }
 
   @override
   List<String> get importedUris => _importedUris ??= <String>[];
 
   /**
    * The list of explicitly imported URIs, e.g. `dart:core`, or `foo/bar.dart`,
    * or `package:foo/bar.dart`.  Empty if [kind] is [CacheSourceKind.part].
    */
   void set importedUris(List<String> _value) {
-    assert(!_finished);
     _importedUris = _value;
   }
 
   @override
   idl.CacheSourceKind get kind => _kind ??= idl.CacheSourceKind.library;
 
   /**
    * The kind of the source.
    */
   void set kind(idl.CacheSourceKind _value) {
-    assert(!_finished);
     _kind = _value;
   }
 
   @override
   List<String> get partUris => _partUris ??= <String>[];
 
   /**
    * The list of part URIs, e.g. `foo/bar.dart`.  Empty if [kind] is
    * [CacheSourceKind.part].
    */
   void set partUris(List<String> _value) {
-    assert(!_finished);
     _partUris = _value;
   }
 
   CacheSourceContentBuilder({List<String> exportedUris, List<String> importedUris, idl.CacheSourceKind kind, List<String> partUris})
     : _exportedUris = exportedUris,
       _importedUris = importedUris,
       _kind = kind,
       _partUris = partUris;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "CaSS");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_exportedUris;
     fb.Offset offset_importedUris;
     fb.Offset offset_partUris;
     if (!(_exportedUris == null || _exportedUris.isEmpty)) {
       offset_exportedUris = fbBuilder.writeList(_exportedUris.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_importedUris == null || _importedUris.isEmpty)) {
       offset_importedUris = fbBuilder.writeList(_importedUris.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_partUris == null || _partUris.isEmpty)) {
@@ skipping 81 matching lines @@
     "importedUris": importedUris,
     "kind": kind,
     "partUris": partUris,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class CacheSourceErrorsInLibraryBuilder extends Object with _CacheSourceErrorsInLibraryMixin implements idl.CacheSourceErrorsInLibrary {
-  bool _finished = false;
-
   List<CacheAnalysisErrorBuilder> _errors;
 
   @override
   List<CacheAnalysisErrorBuilder> get errors => _errors ??= <CacheAnalysisErrorBuilder>[];
 
   /**
    * The list of errors in the source in the library.
    */
   void set errors(List<CacheAnalysisErrorBuilder> _value) {
-    assert(!_finished);
     _errors = _value;
   }
 
   CacheSourceErrorsInLibraryBuilder({List<CacheAnalysisErrorBuilder> errors})
     : _errors = errors;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _errors?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "CSEL");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_errors;
     if (!(_errors == null || _errors.isEmpty)) {
       offset_errors = fbBuilder.writeList(_errors.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_errors != null) {
       fbBuilder.addOffset(0, offset_errors);
     }
     return fbBuilder.endTable();
   }
@@ skipping 37 matching lines @@
   @override
   Map<String, Object> toMap() => {
     "errors": errors,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class CodeRangeBuilder extends Object with _CodeRangeMixin implements idl.CodeRange {
-  bool _finished = false;
-
   int _length;
   int _offset;
 
   @override
   int get length => _length ??= 0;
 
   /**
    * Length of the element code.
    */
   void set length(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _length = _value;
   }
 
   @override
   int get offset => _offset ??= 0;
 
   /**
    * Offset of the element code relative to the beginning of the file.
    */
   void set offset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   CodeRangeBuilder({int length, int offset})
     : _length = length,
       _offset = offset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fbBuilder.startTable();
     if (_length != null && _length != 0) {
       fbBuilder.addUint32(1, _length);
     }
     if (_offset != null && _offset != 0) {
       fbBuilder.addUint32(0, _offset);
     }
     return fbBuilder.endTable();
   }
 }
@@ skipping 40 matching lines @@
   Map<String, Object> toMap() => {
     "length": length,
     "offset": offset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class EntityRefBuilder extends Object with _EntityRefMixin implements idl.EntityRef {
-  bool _finished = false;
-
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<UnlinkedParamBuilder> _syntheticParams;
   EntityRefBuilder _syntheticReturnType;
   List<EntityRefBuilder> _typeArguments;
 
   @override
   List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
@@ skipping 14 matching lines @@
    *
    * 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 implicitFunctionTypeIndices(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _implicitFunctionTypeIndices = _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
   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 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<UnlinkedParamBuilder> get syntheticParams => _syntheticParams ??= <UnlinkedParamBuilder>[];
 
   /**
    * If this [EntityRef] is a reference to a function type whose
    * [FunctionElement] is not in any library (e.g. a function type that was
    * synthesized by a LUB computation), the function parameters.  Otherwise
    * empty.
    */
   void set syntheticParams(List<UnlinkedParamBuilder> _value) {
-    assert(!_finished);
     _syntheticParams = _value;
   }
 
   @override
   EntityRefBuilder get syntheticReturnType => _syntheticReturnType;
 
   /**
    * If this [EntityRef] is a reference to a function type whose
    * [FunctionElement] is not in any library (e.g. a function type that was
    * synthesized by a LUB computation), the return type of the function.
    * Otherwise `null`.
    */
   void set syntheticReturnType(EntityRefBuilder _value) {
-    assert(!_finished);
     _syntheticReturnType = _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 (if any).
    */
   void set typeArguments(List<EntityRefBuilder> _value) {
-    assert(!_finished);
     _typeArguments = _value;
   }
 
   EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<UnlinkedParamBuilder> syntheticParams, EntityRefBuilder syntheticReturnType, List<EntityRefBuilder> typeArguments})
     : _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
       _paramReference = paramReference,
       _reference = reference,
       _slot = slot,
       _syntheticParams = syntheticParams,
       _syntheticReturnType = syntheticReturnType,
       _typeArguments = typeArguments;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _syntheticParams?.forEach((b) => b.flushInformative());
     _syntheticReturnType?.flushInformative();
     _typeArguments?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_syntheticParams;
     fb.Offset offset_syntheticReturnType;
     fb.Offset offset_typeArguments;
     if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
       offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
     }
     if (!(_syntheticParams == null || _syntheticParams.isEmpty)) {
       offset_syntheticParams = fbBuilder.writeList(_syntheticParams.map((b) => b.finish(fbBuilder)).toList());
     }
@@ skipping 116 matching lines @@
     "syntheticParams": syntheticParams,
     "syntheticReturnType": syntheticReturnType,
     "typeArguments": typeArguments,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
-  bool _finished = false;
-
   List<String> _parts;
   String _uri;
 
   @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;
   }
 
   LinkedDependencyBuilder({List<String> parts, String uri})
     : _parts = parts,
       _uri = uri;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_parts;
     fb.Offset offset_uri;
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
     fbBuilder.startTable();
     if (offset_parts != null) {
@@ skipping 48 matching lines @@
   Map<String, Object> toMap() => {
     "parts": parts,
     "uri": uri,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedExportNameBuilder extends Object with _LinkedExportNameMixin implements idl.LinkedExportName {
-  bool _finished = false;
-
   int _dependency;
   idl.ReferenceKind _kind;
   String _name;
   int _unit;
 
   @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;
   }
 
   LinkedExportNameBuilder({int dependency, idl.ReferenceKind kind, String name, int unit})
     : _dependency = dependency,
       _kind = kind,
       _name = name,
       _unit = unit;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   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.addUint8(3, _kind.index);
@@ skipping 68 matching lines @@
     "kind": kind,
     "name": name,
     "unit": unit,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements idl.LinkedLibrary {
-  bool _finished = false;
-
   List<LinkedDependencyBuilder> _dependencies;
   List<int> _exportDependencies;
   List<LinkedExportNameBuilder> _exportNames;
   bool _fallbackMode;
   List<int> _importDependencies;
   int _numPrelinkedDependencies;
   List<LinkedUnitBuilder> _units;
 
   @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 exportDependencies => _exportDependencies ??= <int>[];
 
   /**
    * For each export in [UnlinkedUnit.exports], an index into [dependencies]
    * of the library being exported.
    */
   void set exportDependencies(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _exportDependencies = _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
   bool get fallbackMode => _fallbackMode ??= false;
 
   /**
    * Indicates whether this library was summarized in "fallback mode".  If
    * true, all other fields in the data structure have their default values.
    */
   void set fallbackMode(bool _value) {
-    assert(!_finished);
     _fallbackMode = _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;
   }
 
   @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<int> exportDependencies, List<LinkedExportNameBuilder> exportNames, bool fallbackMode, List<int> importDependencies, int numPrelinkedDependencies, List<LinkedUnitBuilder> units})
     : _dependencies = dependencies,
       _exportDependencies = exportDependencies,
       _exportNames = exportNames,
       _fallbackMode = fallbackMode,
       _importDependencies = importDependencies,
       _numPrelinkedDependencies = numPrelinkedDependencies,
       _units = units;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _dependencies?.forEach((b) => b.flushInformative());
     _exportNames?.forEach((b) => b.flushInformative());
     _units?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "LLib");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_dependencies;
     fb.Offset offset_exportDependencies;
     fb.Offset offset_exportNames;
     fb.Offset offset_importDependencies;
     fb.Offset offset_units;
     if (!(_dependencies == null || _dependencies.isEmpty)) {
       offset_dependencies = fbBuilder.writeList(_dependencies.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_exportDependencies == null || _exportDependencies.isEmpty)) {
       offset_exportDependencies = fbBuilder.writeListUint32(_exportDependencies);
@@ skipping 125 matching lines @@
     "importDependencies": importDependencies,
     "numPrelinkedDependencies": numPrelinkedDependencies,
     "units": units,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements idl.LinkedReference {
-  bool _finished = false;
-
   int _containingReference;
   int _dependency;
   idl.ReferenceKind _kind;
   int _localIndex;
   String _name;
   int _numTypeParameters;
   int _unit;
 
   @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].
    */
   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.  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 localIndex => _localIndex ??= 0;
 
   /**
    * If [kind] is [ReferenceKind.function] (that is, the entity being referred
    * to is a local function), the index of the function within
    * [UnlinkedExecutable.localFunctions].  If [kind] is
    * [ReferenceKind.variable], the index of the variable within
    * [UnlinkedExecutable.localVariables].  Otherwise zero.
    */
   void set localIndex(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _localIndex = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
    * 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 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 declares (does not include type parameters of enclosing entities).
    * Otherwise zero.
    */
   void set numTypeParameters(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
   @override
   int get unit => _unit ??= 0;
 
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [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 unit(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _unit = _value;
   }
 
   LinkedReferenceBuilder({int containingReference, int dependency, idl.ReferenceKind kind, int localIndex, String name, int numTypeParameters, int unit})
     : _containingReference = containingReference,
       _dependency = dependency,
       _kind = kind,
       _localIndex = localIndex,
       _name = name,
       _numTypeParameters = numTypeParameters,
       _unit = unit;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   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(5, _containingReference);
     }
     if (_dependency != null && _dependency != 0) {
       fbBuilder.addUint32(1, _dependency);
@@ skipping 104 matching lines @@
     "name": name,
     "numTypeParameters": numTypeParameters,
     "unit": unit,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
-  bool _finished = false;
-
   List<int> _constCycles;
   List<LinkedReferenceBuilder> _references;
   List<EntityRefBuilder> _types;
 
   @override
   List<int> get constCycles => _constCycles ??= <int>[];
 
   /**
    * List of slot ids (referring to [UnlinkedExecutable.constCycleSlot])
    * corresponding to const constructors that are part of cycles.
    */
   void set constCycles(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _constCycles = _value;
   }
 
   @override
   List<LinkedReferenceBuilder> get references => _references ??= <LinkedReferenceBuilder>[];
 
   /**
    * Information about the resolution of references within the compilation
    * unit.  Each element of [UnlinkedUnit.references] has a corresponding
    * element in this list (at the same index).  If this list has additional
    * elements beyond the number of elements in [UnlinkedUnit.references], those
    * additional elements are references that are only referred to implicitly
    * (e.g. elements involved in inferred or propagated types).
    */
   void set references(List<LinkedReferenceBuilder> _value) {
-    assert(!_finished);
     _references = _value;
   }
 
   @override
   List<EntityRefBuilder> get types => _types ??= <EntityRefBuilder>[];
 
   /**
    * List associating slot ids found inside the unlinked summary for the
    * compilation unit with propagated and inferred types.
    */
   void set types(List<EntityRefBuilder> _value) {
-    assert(!_finished);
     _types = _value;
   }
 
   LinkedUnitBuilder({List<int> constCycles, List<LinkedReferenceBuilder> references, List<EntityRefBuilder> types})
     : _constCycles = constCycles,
       _references = references,
       _types = types;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _references?.forEach((b) => b.flushInformative());
     _types?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_constCycles;
     fb.Offset offset_references;
     fb.Offset offset_types;
     if (!(_constCycles == null || _constCycles.isEmpty)) {
       offset_constCycles = fbBuilder.writeListUint32(_constCycles);
     }
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_types == null || _types.isEmpty)) {
@@ skipping 64 matching lines @@
     "constCycles": constCycles,
     "references": references,
     "types": types,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class PackageBundleBuilder extends Object with _PackageBundleMixin implements idl.PackageBundle {
-  bool _finished = false;
-
   List<LinkedLibraryBuilder> _linkedLibraries;
   List<String> _linkedLibraryUris;
   int _majorVersion;
   int _minorVersion;
   List<String> _unlinkedUnitHashes;
   List<UnlinkedUnitBuilder> _unlinkedUnits;
   List<String> _unlinkedUnitUris;
 
   @override
   List<LinkedLibraryBuilder> get linkedLibraries => _linkedLibraries ??= <LinkedLibraryBuilder>[];
 
   /**
    * Linked libraries.
    */
   void set linkedLibraries(List<LinkedLibraryBuilder> _value) {
-    assert(!_finished);
     _linkedLibraries = _value;
   }
 
   @override
   List<String> get linkedLibraryUris => _linkedLibraryUris ??= <String>[];
 
   /**
    * The list of URIs of items in [linkedLibraries], e.g. `dart:core` or
    * `package:foo/bar.dart`.
    */
   void set linkedLibraryUris(List<String> _value) {
-    assert(!_finished);
     _linkedLibraryUris = _value;
   }
 
   @override
   int get majorVersion => _majorVersion ??= 0;
 
   /**
    * Major version of the summary format.  See
    * [PackageBundleAssembler.currentMajorVersion].
    */
   void set majorVersion(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _majorVersion = _value;
   }
 
   @override
   int get minorVersion => _minorVersion ??= 0;
 
   /**
    * Minor version of the summary format.  See
    * [PackageBundleAssembler.currentMinorVersion].
    */
   void set minorVersion(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _minorVersion = _value;
   }
 
   @override
   List<String> get unlinkedUnitHashes => _unlinkedUnitHashes ??= <String>[];
 
   /**
    * List of MD5 hashes of the files listed in [unlinkedUnitUris].  Each hash
    * is encoded as a hexadecimal string using lower case letters.
    */
   void set unlinkedUnitHashes(List<String> _value) {
-    assert(!_finished);
     _unlinkedUnitHashes = _value;
   }
 
   @override
   List<UnlinkedUnitBuilder> get unlinkedUnits => _unlinkedUnits ??= <UnlinkedUnitBuilder>[];
 
   /**
    * Unlinked information for the compilation units constituting the package.
    */
   void set unlinkedUnits(List<UnlinkedUnitBuilder> _value) {
-    assert(!_finished);
     _unlinkedUnits = _value;
   }
 
   @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;
   }
 
   PackageBundleBuilder({List<LinkedLibraryBuilder> linkedLibraries, List<String> linkedLibraryUris, int majorVersion, int minorVersion, List<String> unlinkedUnitHashes, List<UnlinkedUnitBuilder> unlinkedUnits, List<String> unlinkedUnitUris})
     : _linkedLibraries = linkedLibraries,
       _linkedLibraryUris = linkedLibraryUris,
       _majorVersion = majorVersion,
       _minorVersion = minorVersion,
       _unlinkedUnitHashes = unlinkedUnitHashes,
       _unlinkedUnits = unlinkedUnits,
       _unlinkedUnitUris = unlinkedUnitUris;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _linkedLibraries?.forEach((b) => b.flushInformative());
     _unlinkedUnitHashes = null;
     _unlinkedUnits?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "PBdl");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_linkedLibraries;
     fb.Offset offset_linkedLibraryUris;
     fb.Offset offset_unlinkedUnitHashes;
     fb.Offset offset_unlinkedUnits;
     fb.Offset offset_unlinkedUnitUris;
     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());
@@ skipping 125 matching lines @@
     "unlinkedUnitHashes": unlinkedUnitHashes,
     "unlinkedUnits": unlinkedUnits,
     "unlinkedUnitUris": unlinkedUnitUris,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class PackageIndexBuilder extends Object with _PackageIndexMixin implements idl.PackageIndex {
-  bool _finished = false;
-
   List<idl.IndexSyntheticElementKind> _elementKinds;
   List<int> _elementOffsets;
   List<int> _elementUnits;
   List<String> _strings;
   List<int> _unitLibraryUris;
   List<UnitIndexBuilder> _units;
   List<int> _unitUnitUris;
 
   @override
   List<idl.IndexSyntheticElementKind> get elementKinds => _elementKinds ??= <idl.IndexSyntheticElementKind>[];
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the kind of the synthetic element.
    */
   void set elementKinds(List<idl.IndexSyntheticElementKind> _value) {
-    assert(!_finished);
     _elementKinds = _value;
   }
 
   @override
   List<int> get elementOffsets => _elementOffsets ??= <int>[];
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the offset of the element name relative to the beginning of the file.  The
    * list is sorted in ascending order, so that the client can quickly check
    * whether an element is referenced in this [PackageIndex].
    */
   void set elementOffsets(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _elementOffsets = _value;
   }
 
   @override
   List<int> get elementUnits => _elementUnits ??= <int>[];
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the index into [unitLibraryUris] and [unitUnitUris] for the library
    * specific unit where the element is declared.
    */
   void set elementUnits(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _elementUnits = _value;
   }
 
   @override
   List<String> get strings => _strings ??= <String>[];
 
   /**
    * List of unique element strings used in this [PackageIndex].  The list is
    * sorted in ascending order, so that the client can quickly check the
    * presence of a string in this [PackageIndex].
    */
   void set strings(List<String> _value) {
-    assert(!_finished);
     _strings = _value;
   }
 
   @override
   List<int> get unitLibraryUris => _unitLibraryUris ??= <int>[];
 
   /**
    * Each item of this list corresponds to the library URI of a unique library
    * specific unit referenced in the [PackageIndex].  It is an index into
    * [strings] list.
    */
   void set unitLibraryUris(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _unitLibraryUris = _value;
   }
 
   @override
   List<UnitIndexBuilder> get units => _units ??= <UnitIndexBuilder>[];
 
   /**
    * List of indexes of each unit in this [PackageIndex].
    */
   void set units(List<UnitIndexBuilder> _value) {
-    assert(!_finished);
     _units = _value;
   }
 
   @override
   List<int> get unitUnitUris => _unitUnitUris ??= <int>[];
 
   /**
    * Each item of this list corresponds to the unit URI of a unique library
    * specific unit referenced in the [PackageIndex].  It is an index into
    * [strings] list.
    */
   void set unitUnitUris(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _unitUnitUris = _value;
   }
 
   PackageIndexBuilder({List<idl.IndexSyntheticElementKind> elementKinds, List<int> elementOffsets, List<int> elementUnits, List<String> strings, List<int> unitLibraryUris, List<UnitIndexBuilder> units, List<int> unitUnitUris})
     : _elementKinds = elementKinds,
       _elementOffsets = elementOffsets,
       _elementUnits = elementUnits,
       _strings = strings,
       _unitLibraryUris = unitLibraryUris,
       _units = units,
       _unitUnitUris = unitUnitUris;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _units?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "Indx");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_elementKinds;
     fb.Offset offset_elementOffsets;
     fb.Offset offset_elementUnits;
     fb.Offset offset_strings;
     fb.Offset offset_unitLibraryUris;
     fb.Offset offset_units;
     fb.Offset offset_unitUnitUris;
     if (!(_elementKinds == null || _elementKinds.isEmpty)) {
       offset_elementKinds = fbBuilder.writeListUint8(_elementKinds.map((b) => b.index).toList());
     }
@@ skipping 133 matching lines @@
     "unitLibraryUris": unitLibraryUris,
     "units": units,
     "unitUnitUris": unitUnitUris,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnitIndexBuilder extends Object with _UnitIndexMixin implements idl.UnitIndex {
-  bool _finished = false;
-
   List<idl.IndexNameKind> _definedNameKinds;
   List<int> _definedNameOffsets;
   List<int> _definedNames;
   int _unit;
   List<bool> _usedElementIsQualifiedFlags;
   List<idl.IndexRelationKind> _usedElementKinds;
   List<int> _usedElementLengths;
   List<int> _usedElementOffsets;
   List<int> _usedElements;
   List<bool> _usedNameIsQualifiedFlags;
   List<idl.IndexRelationKind> _usedNameKinds;
   List<int> _usedNameOffsets;
   List<int> _usedNames;
 
   @override
   List<idl.IndexNameKind> get definedNameKinds => _definedNameKinds ??= <idl.IndexNameKind>[];
 
   /**
    * Each item of this list is the kind of an element defined in this unit.
    */
   void set definedNameKinds(List<idl.IndexNameKind> _value) {
-    assert(!_finished);
     _definedNameKinds = _value;
   }
 
   @override
   List<int> get definedNameOffsets => _definedNameOffsets ??= <int>[];
 
   /**
    * Each item of this list is the name offset of an element defined in this
    * unit relative to the beginning of the file.
    */
   void set definedNameOffsets(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _definedNameOffsets = _value;
   }
 
   @override
   List<int> get definedNames => _definedNames ??= <int>[];
 
   /**
    * Each item of this list corresponds to an element defined in this unit.  It
    * is an index into [PackageIndex.strings] list.  The list is sorted in
    * ascending order, so that the client can quickly find name definitions in
    * this [UnitIndex].
    */
   void set definedNames(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _definedNames = _value;
   }
 
   @override
   int get unit => _unit ??= 0;
 
   /**
    * Index into [PackageIndex.unitLibraryUris] and [PackageIndex.unitUnitUris]
    * for the library specific unit that corresponds to this [UnitIndex].
    */
   void set unit(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _unit = _value;
   }
 
   @override
   List<bool> get usedElementIsQualifiedFlags => _usedElementIsQualifiedFlags ??= <bool>[];
 
   /**
    * Each item of this list is the `true` if the corresponding element usage
    * is qualified with some prefix.
    */
   void set usedElementIsQualifiedFlags(List<bool> _value) {
-    assert(!_finished);
     _usedElementIsQualifiedFlags = _value;
   }
 
   @override
   List<idl.IndexRelationKind> get usedElementKinds => _usedElementKinds ??= <idl.IndexRelationKind>[];
 
   /**
    * Each item of this list is the kind of the element usage.
    */
   void set usedElementKinds(List<idl.IndexRelationKind> _value) {
-    assert(!_finished);
     _usedElementKinds = _value;
   }
 
   @override
   List<int> get usedElementLengths => _usedElementLengths ??= <int>[];
 
   /**
    * Each item of this list is the length of the element usage.
    */
   void set usedElementLengths(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _usedElementLengths = _value;
   }
 
   @override
   List<int> get usedElementOffsets => _usedElementOffsets ??= <int>[];
 
   /**
    * Each item of this list is the offset of the element usage relative to the
    * beginning of the file.
    */
   void set usedElementOffsets(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _usedElementOffsets = _value;
   }
 
   @override
   List<int> get usedElements => _usedElements ??= <int>[];
 
   /**
    * Each item of this list is the index into [PackageIndex.elementUnits] and
    * [PackageIndex.elementOffsets].  The list is sorted in ascending order, so
    * that the client can quickly find element references in this [UnitIndex].
    */
   void set usedElements(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _usedElements = _value;
   }
 
   @override
   List<bool> get usedNameIsQualifiedFlags => _usedNameIsQualifiedFlags ??= <bool>[];
 
   /**
    * Each item of this list is the `true` if the corresponding name usage
    * is qualified with some prefix.
    */
   void set usedNameIsQualifiedFlags(List<bool> _value) {
-    assert(!_finished);
     _usedNameIsQualifiedFlags = _value;
   }
 
   @override
   List<idl.IndexRelationKind> get usedNameKinds => _usedNameKinds ??= <idl.IndexRelationKind>[];
 
   /**
    * Each item of this list is the kind of the name usage.
    */
   void set usedNameKinds(List<idl.IndexRelationKind> _value) {
-    assert(!_finished);
     _usedNameKinds = _value;
   }
 
   @override
   List<int> get usedNameOffsets => _usedNameOffsets ??= <int>[];
 
   /**
    * Each item of this list is the offset of the name usage relative to the
    * beginning of the file.
    */
   void set usedNameOffsets(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _usedNameOffsets = _value;
   }
 
   @override
   List<int> get usedNames => _usedNames ??= <int>[];
 
   /**
    * Each item of this list is the index into [PackageIndex.strings] for a
    * used name.  The list is sorted in ascending order, so that the client can
    * quickly find name uses in this [UnitIndex].
    */
   void set usedNames(List<int> _value) {
-    assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _usedNames = _value;
   }
 
   UnitIndexBuilder({List<idl.IndexNameKind> definedNameKinds, List<int> definedNameOffsets, List<int> definedNames, int unit, List<bool> usedElementIsQualifiedFlags, List<idl.IndexRelationKind> usedElementKinds, List<int> usedElementLengths, List<int> usedElementOffsets, List<int> usedElements, List<bool> usedNameIsQualifiedFlags, List<idl.IndexRelationKind> usedNameKinds, List<int> usedNameOffsets, List<int> usedNames})
     : _definedNameKinds = definedNameKinds,
       _definedNameOffsets = definedNameOffsets,
       _definedNames = definedNames,
       _unit = unit,
       _usedElementIsQualifiedFlags = usedElementIsQualifiedFlags,
       _usedElementKinds = usedElementKinds,
       _usedElementLengths = usedElementLengths,
       _usedElementOffsets = usedElementOffsets,
       _usedElements = usedElements,
       _usedNameIsQualifiedFlags = usedNameIsQualifiedFlags,
       _usedNameKinds = usedNameKinds,
       _usedNameOffsets = usedNameOffsets,
       _usedNames = usedNames;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_definedNameKinds;
     fb.Offset offset_definedNameOffsets;
     fb.Offset offset_definedNames;
     fb.Offset offset_usedElementIsQualifiedFlags;
     fb.Offset offset_usedElementKinds;
     fb.Offset offset_usedElementLengths;
     fb.Offset offset_usedElementOffsets;
     fb.Offset offset_usedElements;
     fb.Offset offset_usedNameIsQualifiedFlags;
     fb.Offset offset_usedNameKinds;
@@ skipping 220 matching lines @@
     "usedNameKinds": usedNameKinds,
     "usedNameOffsets": usedNameOffsets,
     "usedNames": usedNames,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements idl.UnlinkedClass {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   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;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this class.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the class.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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
   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<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, CodeRangeBuilder codeRange, 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,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _executables = executables,
       _fields = fields,
       _hasNoSupertype = hasNoSupertype,
@@ skipping 16 matching lines @@
     _executables?.forEach((b) => b.flushInformative());
     _fields?.forEach((b) => b.flushInformative());
     _interfaces?.forEach((b) => b.flushInformative());
     _mixins?.forEach((b) => b.flushInformative());
     _nameOffset = null;
     _supertype?.flushInformative();
     _typeParameters?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     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_supertype;
     fb.Offset offset_typeParameters;
@@ skipping 224 matching lines @@
     "nameOffset": nameOffset,
     "supertype": supertype,
     "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedCombinatorBuilder extends Object with _UnlinkedCombinatorMixin implements idl.UnlinkedCombinator {
-  bool _finished = false;
-
   int _end;
   List<String> _hides;
   int _offset;
   List<String> _shows;
 
   @override
   int get end => _end ??= 0;
 
   /**
    * If this is a `show` combinator, offset of the end of the list of shown
    * names.  Otherwise zero.
    */
   void set end(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _end = _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;
   }
 
   @override
   int get offset => _offset ??= 0;
 
   /**
    * If this is a `show` combinator, offset of the `show` keyword.  Otherwise
    * zero.
    */
   void set offset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _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;
   }
 
   UnlinkedCombinatorBuilder({int end, List<String> hides, int offset, List<String> shows})
     : _end = end,
       _hides = hides,
       _offset = offset,
       _shows = shows;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _end = null;
     _offset = null;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_hides;
     fb.Offset offset_shows;
     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());
     }
     fbBuilder.startTable();
     if (_end != null && _end != 0) {
@@ skipping 72 matching lines @@
     "hides": hides,
     "offset": offset,
     "shows": shows,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
-  bool _finished = false;
-
   List<idl.UnlinkedExprAssignOperator> _assignmentOperators;
   List<double> _doubles;
   List<int> _ints;
   bool _isValidConst;
   List<idl.UnlinkedConstOperation> _operations;
   List<EntityRefBuilder> _references;
   List<String> _strings;
 
   @override
   List<idl.UnlinkedExprAssignOperator> get assignmentOperators => _assignmentOperators ??= <idl.UnlinkedExprAssignOperator>[];
 
   /**
    * Sequence of operators used by assignment operations.
    */
   void set assignmentOperators(List<idl.UnlinkedExprAssignOperator> _value) {
-    assert(!_finished);
     _assignmentOperators = _value;
   }
 
   @override
   List<double> get doubles => _doubles ??= <double>[];
 
   /**
    * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
    */
   void set doubles(List<double> _value) {
-    assert(!_finished);
     _doubles = _value;
   }
 
   @override
   List<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
   bool get isValidConst => _isValidConst ??= false;
 
   /**
    * Indicates whether the expression is a valid potentially constant
    * expression.
    */
   void set isValidConst(bool _value) {
-    assert(!_finished);
     _isValidConst = _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<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;
   }
 
   @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<idl.UnlinkedExprAssignOperator> assignmentOperators, List<double> doubles, List<int> ints, bool isValidConst, List<idl.UnlinkedConstOperation> operations, List<EntityRefBuilder> references, List<String> strings})
     : _assignmentOperators = assignmentOperators,
       _doubles = doubles,
       _ints = ints,
       _isValidConst = isValidConst,
       _operations = operations,
       _references = references,
       _strings = strings;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _references?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_assignmentOperators;
     fb.Offset offset_doubles;
     fb.Offset offset_ints;
     fb.Offset offset_operations;
     fb.Offset offset_references;
     fb.Offset offset_strings;
     if (!(_assignmentOperators == null || _assignmentOperators.isEmpty)) {
       offset_assignmentOperators = fbBuilder.writeListUint8(_assignmentOperators.map((b) => b.index).toList());
     }
     if (!(_doubles == null || _doubles.isEmpty)) {
@@ skipping 124 matching lines @@
     "operations": operations,
     "references": references,
     "strings": strings,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedConstructorInitializerBuilder extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
-  bool _finished = false;
-
   List<String> _argumentNames;
   List<UnlinkedConstBuilder> _arguments;
   UnlinkedConstBuilder _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
 
   @override
   List<String> get argumentNames => _argumentNames ??= <String>[];
 
   /**
    * If there are `m` [arguments] and `n` [argumentNames], then each argument
    * from [arguments] with index `i` such that `n + i - m >= 0`, should be used
    * with the name at `n + i - m`.
    */
   void set argumentNames(List<String> _value) {
-    assert(!_finished);
     _argumentNames = _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;
   }
 
   @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;
   }
 
   UnlinkedConstructorInitializerBuilder({List<String> argumentNames, List<UnlinkedConstBuilder> arguments, UnlinkedConstBuilder expression, idl.UnlinkedConstructorInitializerKind kind, String name})
     : _argumentNames = argumentNames,
       _arguments = arguments,
       _expression = expression,
       _kind = kind,
       _name = name;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _arguments?.forEach((b) => b.flushInformative());
     _expression?.flushInformative();
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_argumentNames;
     fb.Offset offset_arguments;
     fb.Offset offset_expression;
     fb.Offset offset_name;
     if (!(_argumentNames == null || _argumentNames.isEmpty)) {
       offset_argumentNames = fbBuilder.writeList(_argumentNames.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_arguments == null || _arguments.isEmpty)) {
       offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
     }
@@ skipping 92 matching lines @@
     "expression": expression,
     "kind": kind,
     "name": name,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
-  bool _finished = false;
-
   int _length;
   int _offset;
   String _text;
 
   @override
   int get length => _length ??= 0;
 
   /**
    * Length of the documentation comment (prior to replacing '\r\n' with '\n').
    */
   void set length(int _value) {
-    assert(!_finished);
     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
   String get text => _text ??= '';
 
   /**
    * Text of the documentation comment, with '\r\n' replaced by '\n'.
    *
    * References appearing within the doc comment in square brackets are not
    * specially encoded.
    */
   void set text(String _value) {
-    assert(!_finished);
     _text = _value;
   }
 
   UnlinkedDocumentationCommentBuilder({int length, int offset, String text})
     : _length = length,
       _offset = offset,
       _text = text;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   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 (_length != null && _length != 0) {
       fbBuilder.addUint32(0, _length);
     }
     if (_offset != null && _offset != 0) {
       fbBuilder.addUint32(2, _offset);
@@ skipping 56 matching lines @@
     "length": length,
     "offset": offset,
     "text": text,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedEnumBuilder extends Object with _UnlinkedEnumMixin implements idl.UnlinkedEnum {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
   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
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the enum.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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
   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({List<UnlinkedConstBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedEnumValueBuilder> values})
     : _annotations = annotations,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _name = name,
       _nameOffset = nameOffset,
       _values = values;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _codeRange = null;
     _documentationComment = null;
     _nameOffset = null;
     _values?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     fb.Offset offset_values;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_codeRange != null) {
       offset_codeRange = _codeRange.finish(fbBuilder);
@@ skipping 108 matching lines @@
     "name": name,
     "nameOffset": nameOffset,
     "values": values,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedEnumValueBuilder extends Object with _UnlinkedEnumValueMixin implements idl.UnlinkedEnumValue {
-  bool _finished = false;
-
   UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
 
   @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;
   }
 
   UnlinkedEnumValueBuilder({UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset})
     : _documentationComment = documentationComment,
       _name = name,
       _nameOffset = nameOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _documentationComment = null;
     _nameOffset = null;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (offset_documentationComment != null) {
@@ skipping 60 matching lines @@
     "documentationComment": documentationComment,
     "name": name,
     "nameOffset": nameOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExecutableBuilder extends Object with _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   UnlinkedConstBuilder _bodyExpr;
   CodeRangeBuilder _codeRange;
   List<UnlinkedConstructorInitializerBuilder> _constantInitializers;
   int _constCycleSlot;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   int _inferredReturnTypeSlot;
   bool _isAbstract;
   bool _isAsynchronous;
   bool _isConst;
@@ skipping 18 matching lines @@
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this executable.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   UnlinkedConstBuilder get bodyExpr => _bodyExpr;
 
   /**
    * If this executable's function body is declared using `=>`, the expression
    * to the right of the `=>`.  May be omitted if neither type inference nor
    * constant evaluation depends on the function body.
    */
   void set bodyExpr(UnlinkedConstBuilder _value) {
-    assert(!_finished);
     _bodyExpr = _value;
   }
 
   @override
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the executable.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _value;
   }
 
   @override
   List<UnlinkedConstructorInitializerBuilder> get constantInitializers => _constantInitializers ??= <UnlinkedConstructorInitializerBuilder>[];
 
   /**
    * If a constant [UnlinkedExecutableKind.constructor], the constructor
    * initializers.  Otherwise empty.
    */
   void set constantInitializers(List<UnlinkedConstructorInitializerBuilder> _value) {
-    assert(!_finished);
     _constantInitializers = _value;
   }
 
   @override
   int get constCycleSlot => _constCycleSlot ??= 0;
 
   /**
    * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
    * a nonzero slot id which is unique within this compilation unit.  If this id
    * is found in [LinkedUnit.constCycles], then this constructor is part of a
    * cycle.
    *
    * Otherwise, zero.
    */
   void set constCycleSlot(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _constCycleSlot = _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
   int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
 
   /**
    * 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 inferredReturnTypeSlot(int _value) {
-    assert(!_finished);
     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 isAsynchronous => _isAsynchronous ??= false;
 
   /**
    * Indicates whether the executable has body marked as being asynchronous.
    */
   void set isAsynchronous(bool _value) {
-    assert(!_finished);
     _isAsynchronous = _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 isGenerator => _isGenerator ??= false;
 
   /**
    * Indicates whether the executable has body marked as being a generator.
    */
   void set isGenerator(bool _value) {
-    assert(!_finished);
     _isGenerator = _value;
   }
 
   @override
   bool get isRedirectedConstructor => _isRedirectedConstructor ??= false;
 
   /**
    * Indicates whether the executable is a redirected constructor.
    */
   void set isRedirectedConstructor(bool _value) {
-    assert(!_finished);
     _isRedirectedConstructor = _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
   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;
   }
 
   @override
   List<UnlinkedExecutableBuilder> get localFunctions => _localFunctions ??= <UnlinkedExecutableBuilder>[];
 
   /**
    * The list of local functions.
    */
   void set localFunctions(List<UnlinkedExecutableBuilder> _value) {
-    assert(!_finished);
     _localFunctions = _value;
   }
 
   @override
   List<UnlinkedLabelBuilder> get localLabels => _localLabels ??= <UnlinkedLabelBuilder>[];
 
   /**
    * The list of local labels.
    */
   void set localLabels(List<UnlinkedLabelBuilder> _value) {
-    assert(!_finished);
     _localLabels = _value;
   }
 
   @override
   List<UnlinkedVariableBuilder> get localVariables => _localVariables ??= <UnlinkedVariableBuilder>[];
 
   /**
    * The list of local variables.
    */
   void set localVariables(List<UnlinkedVariableBuilder> _value) {
-    assert(!_finished);
     _localVariables = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   void set name(String _value) {
-    assert(!_finished);
     _name = _value;
   }
 
   @override
   int get nameEnd => _nameEnd ??= 0;
 
   /**
    * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
    * the offset of the end of the constructor name.  Otherwise zero.
    */
   void set nameEnd(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameEnd = _value;
   }
 
   @override
   int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the executable name relative to the beginning of the file.  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the offset of the class name (i.e. the
    * offset of the second "C" in "class C { C(); }").
    */
   void set nameOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _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
   int get periodOffset => _periodOffset ??= 0;
 
   /**
    * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
    * the offset of the period before the constructor name.  Otherwise zero.
    */
   void set periodOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _periodOffset = _value;
   }
 
   @override
   EntityRefBuilder get redirectedConstructor => _redirectedConstructor;
 
   /**
    * If [isRedirectedConstructor] and [isFactory] are both `true`, the
    * constructor to which this constructor redirects; otherwise empty.
    */
   void set redirectedConstructor(EntityRefBuilder _value) {
-    assert(!_finished);
     _redirectedConstructor = _value;
   }
 
   @override
   String get redirectedConstructorName => _redirectedConstructorName ??= '';
 
   /**
    * If [isRedirectedConstructor] is `true` and [isFactory] is `false`, the
    * name of the constructor that this constructor redirects to; otherwise
    * empty.
    */
   void set redirectedConstructorName(String _value) {
-    assert(!_finished);
     _redirectedConstructorName = _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.  Absent for executables
    * associated with variable initializers and closures, since these
    * executables may have return types that are not accessible via direct
    * imports.
    */
   void set returnType(EntityRefBuilder _value) {
-    assert(!_finished);
     _returnType = _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
   int get visibleLength => _visibleLength ??= 0;
 
   /**
    * If a local function, the length of the visible range; zero otherwise.
    */
   void set visibleLength(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleLength = _value;
   }
 
   @override
   int get visibleOffset => _visibleOffset ??= 0;
 
   /**
    * If a local function, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
   UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, UnlinkedConstBuilder bodyExpr, CodeRangeBuilder codeRange, List<UnlinkedConstructorInitializerBuilder> constantInitializers, int constCycleSlot, UnlinkedDocumentationCommentBuilder documentationComment, int inferredReturnTypeSlot, bool isAbstract, bool isAsynchronous, bool isConst, bool isExternal, bool isFactory, bool isGenerator, bool isRedirectedConstructor, bool isStatic, idl.UnlinkedExecutableKind kind, List<UnlinkedExecutableBuilder> localFunctions, List<UnlinkedLabelBuilder> localLabels, List<UnlinkedVariableBuilder> localVariables, String name, int nameEnd, int nameOffset, List<UnlinkedParamBuilder> parameters, int periodOffset, EntityRefBuilder redirectedConstructor, String redirectedConstructorName, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters, int visibleLength, int visibleOffset})
     : _annotations = annotations,
       _bodyExpr = bodyExpr,
       _codeRange = codeRange,
       _constantInitializers = constantInitializers,
       _constCycleSlot = constCycleSlot,
@@ skipping 40 matching lines @@
     _nameEnd = null;
     _nameOffset = null;
     _parameters?.forEach((b) => b.flushInformative());
     _periodOffset = null;
     _redirectedConstructor?.flushInformative();
     _returnType?.flushInformative();
     _typeParameters?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_bodyExpr;
     fb.Offset offset_codeRange;
     fb.Offset offset_constantInitializers;
     fb.Offset offset_documentationComment;
     fb.Offset offset_localFunctions;
     fb.Offset offset_localLabels;
     fb.Offset offset_localVariables;
     fb.Offset offset_name;
     fb.Offset offset_parameters;
@@ skipping 432 matching lines @@
     "typeParameters": typeParameters,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   int _offset;
   int _uriEnd;
   int _uriOffset;
 
   @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 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
   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;
   }
 
   UnlinkedExportNonPublicBuilder({List<UnlinkedConstBuilder> annotations, int offset, int uriEnd, int uriOffset})
     : _annotations = annotations,
       _offset = offset,
       _uriEnd = uriEnd,
       _uriOffset = uriOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _offset = null;
     _uriEnd = null;
     _uriOffset = null;
   }
 
   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(3, offset_annotations);
     }
     if (_offset != null && _offset != 0) {
       fbBuilder.addUint32(0, _offset);
@@ skipping 68 matching lines @@
     "offset": offset,
     "uriEnd": uriEnd,
     "uriOffset": uriOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExportPublicBuilder extends Object with _UnlinkedExportPublicMixin implements idl.UnlinkedExportPublic {
-  bool _finished = false;
-
   List<UnlinkedCombinatorBuilder> _combinators;
   String _uri;
 
   @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;
   }
 
   UnlinkedExportPublicBuilder({List<UnlinkedCombinatorBuilder> combinators, String uri})
     : _combinators = combinators,
       _uri = uri;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _combinators?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_combinators;
     fb.Offset offset_uri;
     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_combinators != null) {
@@ skipping 48 matching lines @@
   Map<String, Object> toMap() => {
     "combinators": combinators,
     "uri": uri,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedImportBuilder extends Object with _UnlinkedImportMixin implements idl.UnlinkedImport {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   List<UnlinkedCombinatorBuilder> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _offset;
   int _prefixOffset;
   int _prefixReference;
   String _uri;
   int _uriEnd;
   int _uriOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this import declaration.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   List<UnlinkedCombinatorBuilder> get combinators => _combinators ??= <UnlinkedCombinatorBuilder>[];
 
   /**
    * Combinators contained in this import declaration.
    */
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
-    assert(!_finished);
     _combinators = _value;
   }
 
   @override
   bool get isDeferred => _isDeferred ??= false;
 
   /**
    * Indicates whether the import declaration uses the `deferred` keyword.
    */
   void set isDeferred(bool _value) {
-    assert(!_finished);
     _isDeferred = _value;
   }
 
   @override
   bool get isImplicit => _isImplicit ??= false;
 
   /**
    * Indicates whether the import declaration is implicit.
    */
   void set isImplicit(bool _value) {
-    assert(!_finished);
     _isImplicit = _value;
   }
 
   @override
   int get offset => _offset ??= 0;
 
   /**
    * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
    * is true, zero.
    */
   void set offset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _offset = _value;
   }
 
   @override
   int get 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 uriOffset => _uriOffset ??= 0;
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.  If [isImplicit] is true, zero.
    */
   void set uriOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _uriOffset = _value;
   }
 
   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,
       _offset = offset,
       _prefixOffset = prefixOffset,
       _prefixReference = prefixReference,
       _uri = uri,
       _uriEnd = uriEnd,
       _uriOffset = uriOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _combinators?.forEach((b) => b.flushInformative());
     _offset = null;
     _prefixOffset = null;
     _uriEnd = null;
     _uriOffset = null;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_combinators;
     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) {
@@ skipping 148 matching lines @@
     "uri": uri,
     "uriEnd": uriEnd,
     "uriOffset": uriOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedLabelBuilder extends Object with _UnlinkedLabelMixin implements idl.UnlinkedLabel {
-  bool _finished = false;
-
   bool _isOnSwitchMember;
   bool _isOnSwitchStatement;
   String _name;
   int _nameOffset;
 
   @override
   bool get isOnSwitchMember => _isOnSwitchMember ??= false;
 
   /**
    * Return `true` if this label is associated with a `switch` member (`case` or
    * `default`).
    */
   void set isOnSwitchMember(bool _value) {
-    assert(!_finished);
     _isOnSwitchMember = _value;
   }
 
   @override
   bool get isOnSwitchStatement => _isOnSwitchStatement ??= false;
 
   /**
    * Return `true` if this label is associated with a `switch` statement.
    */
   void set isOnSwitchStatement(bool _value) {
-    assert(!_finished);
     _isOnSwitchStatement = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the label.
    */
   void set name(String _value) {
-    assert(!_finished);
     _name = _value;
   }
 
   @override
   int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the label relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   UnlinkedLabelBuilder({bool isOnSwitchMember, bool isOnSwitchStatement, String name, int nameOffset})
     : _isOnSwitchMember = isOnSwitchMember,
       _isOnSwitchStatement = isOnSwitchStatement,
       _name = name,
       _nameOffset = nameOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _nameOffset = null;
   }
 
   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 (_isOnSwitchMember == true) {
       fbBuilder.addBool(2, true);
     }
     if (_isOnSwitchStatement == true) {
       fbBuilder.addBool(3, true);
@@ skipping 68 matching lines @@
     "isOnSwitchStatement": isOnSwitchStatement,
     "name": name,
     "nameOffset": nameOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   String _defaultValueCode;
   int _inferredTypeSlot;
   UnlinkedExecutableBuilder _initializer;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   idl.UnlinkedParamKind _kind;
   String _name;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this parameter.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the parameter.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _value;
   }
 
   @override
   String get defaultValueCode => _defaultValueCode ??= '';
 
   /**
    * If the parameter has a default value, the source text of the constant
    * expression in the default value.  Otherwise the empty string.
    */
   void set defaultValueCode(String _value) {
-    assert(!_finished);
     _defaultValueCode = _value;
   }
 
   @override
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
    * 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 inferredTypeSlot(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
   @override
   UnlinkedExecutableBuilder get initializer => _initializer;
 
   /**
    * The synthetic initializer function of the parameter.  Absent if the variable
    * does not have an initializer.
    */
   void set initializer(UnlinkedExecutableBuilder _value) {
-    assert(!_finished);
     _initializer = _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
   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<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
-    assert(!_finished);
     _parameters = _value;
   }
 
   @override
   EntityRefBuilder get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if the type is
    * implicit.
    */
   void set type(EntityRefBuilder _value) {
-    assert(!_finished);
     _type = _value;
   }
 
   @override
   int get visibleLength => _visibleLength ??= 0;
 
   /**
    * The length of the visible range.
    */
   void set visibleLength(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleLength = _value;
   }
 
   @override
   int get visibleOffset => _visibleOffset ??= 0;
 
   /**
    * The beginning of the visible range.
    */
   void set visibleOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
   UnlinkedParamBuilder({List<UnlinkedConstBuilder> annotations, CodeRangeBuilder codeRange, String defaultValueCode, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isFunctionTyped, bool isInitializingFormal, idl.UnlinkedParamKind kind, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder type, int visibleLength, int visibleOffset})
     : _annotations = annotations,
       _codeRange = codeRange,
       _defaultValueCode = defaultValueCode,
       _inferredTypeSlot = inferredTypeSlot,
       _initializer = initializer,
@@ skipping 14 matching lines @@
     _annotations?.forEach((b) => b.flushInformative());
     _codeRange = null;
     _defaultValueCode = null;
     _initializer?.flushInformative();
     _nameOffset = null;
     _parameters?.forEach((b) => b.flushInformative());
     _type?.flushInformative();
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_defaultValueCode;
     fb.Offset offset_initializer;
     fb.Offset offset_name;
     fb.Offset offset_parameters;
     fb.Offset offset_type;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
@@ skipping 212 matching lines @@
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   int _uriEnd;
   int _uriOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this part declaration.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _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
   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;
   }
 
   UnlinkedPartBuilder({List<UnlinkedConstBuilder> annotations, int uriEnd, int uriOffset})
     : _annotations = annotations,
       _uriEnd = uriEnd,
       _uriOffset = uriOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _uriEnd = null;
     _uriOffset = null;
   }
 
   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(2, offset_annotations);
     }
     if (_uriEnd != null && _uriEnd != 0) {
       fbBuilder.addUint32(0, _uriEnd);
@@ skipping 56 matching lines @@
     "annotations": annotations,
     "uriEnd": uriEnd,
     "uriOffset": uriOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements idl.UnlinkedPublicName {
-  bool _finished = false;
-
   idl.ReferenceKind _kind;
   List<UnlinkedPublicNameBuilder> _members;
   String _name;
   int _numTypeParameters;
 
   @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
   List<UnlinkedPublicNameBuilder> get members => _members ??= <UnlinkedPublicNameBuilder>[];
 
   /**
    * If this [UnlinkedPublicName] is a class, the list of members which can be
    * referenced statically - static fields, static methods, and constructors.
    * Otherwise empty.
    *
    * Unnamed constructors are not included since they do not constitute a
    * separate name added to any namespace.
    */
   void set members(List<UnlinkedPublicNameBuilder> _value) {
-    assert(!_finished);
     _members = _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;
   }
 
   UnlinkedPublicNameBuilder({idl.ReferenceKind kind, List<UnlinkedPublicNameBuilder> members, String name, int numTypeParameters})
     : _kind = kind,
       _members = members,
       _name = name,
       _numTypeParameters = numTypeParameters;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _members?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_members;
     fb.Offset offset_name;
     if (!(_members == null || _members.isEmpty)) {
       offset_members = fbBuilder.writeList(_members.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (_kind != null && _kind != idl.ReferenceKind.classOrEnum) {
@@ skipping 72 matching lines @@
     "members": members,
     "name": name,
     "numTypeParameters": numTypeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements idl.UnlinkedPublicNamespace {
-  bool _finished = false;
-
   List<UnlinkedExportPublicBuilder> _exports;
   List<UnlinkedPublicNameBuilder> _names;
   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<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<UnlinkedExportPublicBuilder> exports, List<UnlinkedPublicNameBuilder> names, List<String> parts})
     : _exports = exports,
       _names = names,
       _parts = parts;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _exports?.forEach((b) => b.flushInformative());
     _names?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "UPNS");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_exports;
     fb.Offset offset_names;
     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 (!(_parts == null || _parts.isEmpty)) {
@@ skipping 69 matching lines @@
     "exports": exports,
     "names": names,
     "parts": parts,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedReferenceBuilder extends Object with _UnlinkedReferenceMixin implements idl.UnlinkedReference {
-  bool _finished = false;
-
   String _name;
   int _prefixReference;
 
   @override
   String get name => _name ??= '';
 
   /**
    * 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".
    * For the pseudo-type `bottom`, the string is "*bottom*".
    */
   void set name(String _value) {
-    assert(!_finished);
     _name = _value;
   }
 
   @override
   int get prefixReference => _prefixReference ??= 0;
 
   /**
    * Prefix used to refer to the entity, or zero if no prefix is used.  This is
    * an index into [UnlinkedUnit.references].
    *
    * Prefix references must always point backward; that is, for all i, if
    * UnlinkedUnit.references[i].prefixReference != 0, then
    * UnlinkedUnit.references[i].prefixReference < i.
    */
   void set prefixReference(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _prefixReference = _value;
   }
 
   UnlinkedReferenceBuilder({String name, int prefixReference})
     : _name = name,
       _prefixReference = prefixReference;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
   }
 
   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 (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_prefixReference != null && _prefixReference != 0) {
       fbBuilder.addUint32(1, _prefixReference);
@@ skipping 44 matching lines @@
   Map<String, Object> toMap() => {
     "name": name,
     "prefixReference": prefixReference,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedTypedefBuilder extends Object with _UnlinkedTypedefMixin implements idl.UnlinkedTypedef {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   String _name;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this typedef.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the typedef.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
    * Parameters of the executable, if any.
    */
   void set parameters(List<UnlinkedParamBuilder> _value) {
-    assert(!_finished);
     _parameters = _value;
   }
 
   @override
   EntityRefBuilder get returnType => _returnType;
 
   /**
    * Return type of the typedef.
    */
   void set returnType(EntityRefBuilder _value) {
-    assert(!_finished);
     _returnType = _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;
   }
 
   UnlinkedTypedefBuilder({List<UnlinkedConstBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, String name, int nameOffset, List<UnlinkedParamBuilder> parameters, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters})
     : _annotations = annotations,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _name = name,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _returnType = returnType,
       _typeParameters = typeParameters;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _codeRange = null;
     _documentationComment = null;
     _nameOffset = null;
     _parameters?.forEach((b) => b.flushInformative());
     _returnType?.flushInformative();
     _typeParameters?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_documentationComment;
     fb.Offset offset_name;
     fb.Offset offset_parameters;
     fb.Offset offset_returnType;
     fb.Offset offset_typeParameters;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
@@ skipping 140 matching lines @@
     "parameters": parameters,
     "returnType": returnType,
     "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedTypeParamBuilder extends Object with _UnlinkedTypeParamMixin implements idl.UnlinkedTypeParam {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   EntityRefBuilder _bound;
   CodeRangeBuilder _codeRange;
   String _name;
   int _nameOffset;
 
   @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
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the type parameter.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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;
   }
 
   UnlinkedTypeParamBuilder({List<UnlinkedConstBuilder> annotations, EntityRefBuilder bound, CodeRangeBuilder codeRange, String name, int nameOffset})
     : _annotations = annotations,
       _bound = bound,
       _codeRange = codeRange,
       _name = name,
       _nameOffset = nameOffset;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _bound?.flushInformative();
     _codeRange = null;
     _nameOffset = null;
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_bound;
     fb.Offset offset_codeRange;
     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);
     }
@@ skipping 92 matching lines @@
     "codeRange": codeRange,
     "name": name,
     "nameOffset": nameOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
-  bool _finished = false;
-
   List<UnlinkedClassBuilder> _classes;
   CodeRangeBuilder _codeRange;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
   String _fallbackModePath;
   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
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the unit.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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
   String get fallbackModePath => _fallbackModePath ??= '';
 
   /**
    * If this compilation unit was summarized in fallback mode, the path where
    * the compilation unit may be found on disk.  Otherwise empty.
    *
    * When this field is non-empty, all other fields in the data structure have
    * their default values.
    */
   void set fallbackModePath(String _value) {
-    assert(!_finished);
     _fallbackModePath = _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
   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<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({List<UnlinkedClassBuilder> classes, CodeRangeBuilder codeRange, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, String fallbackModePath, 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,
       _codeRange = codeRange,
       _enums = enums,
       _executables = executables,
       _exports = exports,
       _fallbackModePath = fallbackModePath,
@@ skipping 29 matching lines @@
     _typedefs?.forEach((b) => b.flushInformative());
     _variables?.forEach((b) => b.flushInformative());
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "UUnt");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_classes;
     fb.Offset offset_codeRange;
     fb.Offset offset_enums;
     fb.Offset offset_executables;
     fb.Offset offset_exports;
     fb.Offset offset_fallbackModePath;
     fb.Offset offset_imports;
     fb.Offset offset_libraryAnnotations;
     fb.Offset offset_libraryDocumentationComment;
     fb.Offset offset_libraryName;
@@ skipping 285 matching lines @@
     "references": references,
     "typedefs": typedefs,
     "variables": variables,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedVariableBuilder extends Object with _UnlinkedVariableMixin implements idl.UnlinkedVariable {
-  bool _finished = false;
-
   List<UnlinkedConstBuilder> _annotations;
   CodeRangeBuilder _codeRange;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   int _inferredTypeSlot;
   UnlinkedExecutableBuilder _initializer;
   bool _isConst;
   bool _isFinal;
   bool _isStatic;
   String _name;
   int _nameOffset;
   int _propagatedTypeSlot;
   EntityRefBuilder _type;
   int _visibleLength;
   int _visibleOffset;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this variable.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
-    assert(!_finished);
     _annotations = _value;
   }
 
   @override
   CodeRangeBuilder get codeRange => _codeRange;
 
   /**
    * Code range of the variable.
    */
   void set codeRange(CodeRangeBuilder _value) {
-    assert(!_finished);
     _codeRange = _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
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
    * 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 inferredTypeSlot(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
   @override
   UnlinkedExecutableBuilder get initializer => _initializer;
 
   /**
    * The synthetic initializer function of the variable.  Absent if the variable
    * does not have an initializer.
    */
   void set initializer(UnlinkedExecutableBuilder _value) {
-    assert(!_finished);
     _initializer = _value;
   }
 
   @override
   bool get isConst => _isConst ??= false;
 
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   void set isConst(bool _value) {
-    assert(!_finished);
     _isConst = _value;
   }
 
   @override
   bool get isFinal => _isFinal ??= false;
 
   /**
    * Indicates whether the variable is declared using the `final` keyword.
    */
   void set isFinal(bool _value) {
-    assert(!_finished);
     _isFinal = _value;
   }
 
   @override
   bool get 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
   String get name => _name ??= '';
 
   /**
    * Name of the variable.
    */
   void set name(String _value) {
-    assert(!_finished);
     _name = _value;
   }
 
   @override
   int get nameOffset => _nameOffset ??= 0;
 
   /**
    * Offset of the variable name relative to the beginning of the file.
    */
   void set nameOffset(int _value) {
-    assert(!_finished);
     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
   EntityRefBuilder get type => _type;
 
   /**
    * Declared type of the variable.  Absent if the type is implicit.
    */
   void set type(EntityRefBuilder _value) {
-    assert(!_finished);
     _type = _value;
   }
 
   @override
   int get visibleLength => _visibleLength ??= 0;
 
   /**
    * If a local variable, the length of the visible range; zero otherwise.
    */
   void set visibleLength(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleLength = _value;
   }
 
   @override
   int get visibleOffset => _visibleOffset ??= 0;
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int _value) {
-    assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
   UnlinkedVariableBuilder({List<UnlinkedConstBuilder> annotations, CodeRangeBuilder codeRange, UnlinkedDocumentationCommentBuilder documentationComment, int inferredTypeSlot, UnlinkedExecutableBuilder initializer, bool isConst, bool isFinal, bool isStatic, String name, int nameOffset, int propagatedTypeSlot, EntityRefBuilder type, int visibleLength, int visibleOffset})
     : _annotations = annotations,
       _codeRange = codeRange,
       _documentationComment = documentationComment,
       _inferredTypeSlot = inferredTypeSlot,
       _initializer = initializer,
@@ skipping 13 matching lines @@
   void flushInformative() {
     _annotations?.forEach((b) => b.flushInformative());
     _codeRange = null;
     _documentationComment = null;
     _initializer?.flushInformative();
     _nameOffset = null;
     _type?.flushInformative();
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
-    assert(!_finished);
-    _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_codeRange;
     fb.Offset offset_documentationComment;
     fb.Offset offset_initializer;
     fb.Offset offset_name;
     fb.Offset offset_type;
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_codeRange != null) {
@@ skipping 207 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }