Ensure that summary builders aren't used after call to finish()

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 'dart:convert';
@@ skipping 24 matching lines @@
 
   PrelinkedDependency.fromJson(Map json)
     : _uri = json["uri"];
 
   String get uri => _uri ?? '';
 }
 
 class PrelinkedDependencyBuilder {
   final Map _json = {};
 
+  bool _finished = false;

[Brian Wilkerson, 2015/12/14 16:54:01]

Might be cleaner to reverse the sense of these fields to get rid of all of the
exclamation points. Your call.

+
   PrelinkedDependencyBuilder(builder.BuilderContext context);
 
   void set uri(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("uri"));
     if (_value != null) {
       _json["uri"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 PrelinkedDependencyBuilder encodePrelinkedDependency(builder.BuilderContext builderContext, {String uri}) {
   PrelinkedDependencyBuilder builder = new PrelinkedDependencyBuilder(builderContext);
   builder.uri = uri;
   return builder;
 }
 
 class PrelinkedLibrary {
   UnlinkedLibrary _unlinked;
@@ skipping 11 matching lines @@
 
   UnlinkedLibrary get unlinked => _unlinked;
   List<PrelinkedDependency> get dependencies => _dependencies ?? const <PrelinkedDependency>[];
   List<int> get importDependencies => _importDependencies ?? const <int>[];
   List<PrelinkedReference> get references => _references ?? const <PrelinkedReference>[];
 }
 
 class PrelinkedLibraryBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   PrelinkedLibraryBuilder(builder.BuilderContext context);
 
   void set unlinked(UnlinkedLibraryBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unlinked"));
     if (_value != null) {
       _json["unlinked"] = _value.finish();
     }
   }
 
   void set dependencies(List<PrelinkedDependencyBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("dependencies"));
     if (_value != null || _value.isEmpty) {
       _json["dependencies"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set importDependencies(List<int> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("importDependencies"));
     if (_value != null || _value.isEmpty) {
       _json["importDependencies"] = _value.toList();
     }
   }
 
   void set references(List<PrelinkedReferenceBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("references"));
     if (_value != null || _value.isEmpty) {
       _json["references"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   List<int> toBuffer() => UTF8.encode(JSON.encode(finish()));
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 PrelinkedLibraryBuilder encodePrelinkedLibrary(builder.BuilderContext builderContext, {UnlinkedLibraryBuilder unlinked, List<PrelinkedDependencyBuilder> dependencies, List<int> importDependencies, List<PrelinkedReferenceBuilder> references}) {
   PrelinkedLibraryBuilder builder = new PrelinkedLibraryBuilder(builderContext);
   builder.unlinked = unlinked;
   builder.dependencies = dependencies;
   builder.importDependencies = importDependencies;
   builder.references = references;
   return builder;
 }
 
 class PrelinkedReference {
   int _dependency;
   PrelinkedReferenceKind _kind;
   int _unit;
 
   PrelinkedReference.fromJson(Map json)
     : _dependency = json["dependency"],
       _kind = json["kind"] == null ? null : PrelinkedReferenceKind.values[json["kind"]],
       _unit = json["unit"];
 
   int get dependency => _dependency ?? 0;
   PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
   int get unit => _unit ?? 0;
 }
 
 class PrelinkedReferenceBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   PrelinkedReferenceBuilder(builder.BuilderContext context);
 
   void set dependency(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("dependency"));
     if (_value != null) {
       _json["dependency"] = _value;
     }
   }
 
   void set kind(PrelinkedReferenceKind _value) {
+    assert(!_finished);
     assert(!_json.containsKey("kind"));
     if (_value != null || _value == PrelinkedReferenceKind.classOrEnum) {
       _json["kind"] = _value.index;
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 PrelinkedReferenceBuilder encodePrelinkedReference(builder.BuilderContext builderContext, {int dependency, PrelinkedReferenceKind kind, int unit}) {
   PrelinkedReferenceBuilder builder = new PrelinkedReferenceBuilder(builderContext);
   builder.dependency = dependency;
   builder.kind = kind;
   builder.unit = unit;
   return builder;
 }
 
@@ skipping 29 matching lines @@
   List<UnlinkedTypeRef> get interfaces => _interfaces ?? const <UnlinkedTypeRef>[];
   List<UnlinkedVariable> get fields => _fields ?? const <UnlinkedVariable>[];
   List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
   bool get isAbstract => _isAbstract ?? false;
   bool get isMixinApplication => _isMixinApplication ?? false;
 }
 
 class UnlinkedClassBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedClassBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (_value != null || _value.isEmpty) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set supertype(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("supertype"));
     if (_value != null) {
       _json["supertype"] = _value.finish();
     }
   }
 
   void set mixins(List<UnlinkedTypeRefBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("mixins"));
     if (_value != null || _value.isEmpty) {
       _json["mixins"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set interfaces(List<UnlinkedTypeRefBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("interfaces"));
     if (_value != null || _value.isEmpty) {
       _json["interfaces"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set fields(List<UnlinkedVariableBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("fields"));
     if (_value != null || _value.isEmpty) {
       _json["fields"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set executables(List<UnlinkedExecutableBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("executables"));
     if (_value != null || _value.isEmpty) {
       _json["executables"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set isAbstract(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isAbstract"));
     if (_value != null) {
       _json["isAbstract"] = _value;
     }
   }
 
   void set isMixinApplication(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isMixinApplication"));
     if (_value != null) {
       _json["isMixinApplication"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedClassBuilder encodeUnlinkedClass(builder.BuilderContext builderContext, {String name, int unit, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder supertype, List<UnlinkedTypeRefBuilder> mixins, List<UnlinkedTypeRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication}) {
   UnlinkedClassBuilder builder = new UnlinkedClassBuilder(builderContext);
   builder.name = name;
   builder.unit = unit;
   builder.typeParameters = typeParameters;
   builder.supertype = supertype;
   builder.mixins = mixins;
   builder.interfaces = interfaces;
@@ skipping 12 matching lines @@
     : _shows = json["shows"]?.map((x) => new UnlinkedCombinatorName.fromJson(x))?.toList(),
       _hides = json["hides"]?.map((x) => new UnlinkedCombinatorName.fromJson(x))?.toList();
 
   List<UnlinkedCombinatorName> get shows => _shows ?? const <UnlinkedCombinatorName>[];
   List<UnlinkedCombinatorName> get hides => _hides ?? const <UnlinkedCombinatorName>[];
 }
 
 class UnlinkedCombinatorBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedCombinatorBuilder(builder.BuilderContext context);
 
   void set shows(List<UnlinkedCombinatorNameBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("shows"));
     if (_value != null || _value.isEmpty) {
       _json["shows"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set hides(List<UnlinkedCombinatorNameBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("hides"));
     if (_value != null || _value.isEmpty) {
       _json["hides"] = _value.map((b) => b.finish()).toList();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedCombinatorBuilder encodeUnlinkedCombinator(builder.BuilderContext builderContext, {List<UnlinkedCombinatorNameBuilder> shows, List<UnlinkedCombinatorNameBuilder> hides}) {
   UnlinkedCombinatorBuilder builder = new UnlinkedCombinatorBuilder(builderContext);
   builder.shows = shows;
   builder.hides = hides;
   return builder;
 }
 
 class UnlinkedCombinatorName {
   String _name;
 
   UnlinkedCombinatorName.fromJson(Map json)
     : _name = json["name"];
 
   String get name => _name ?? '';
 }
 
 class UnlinkedCombinatorNameBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedCombinatorNameBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedCombinatorNameBuilder encodeUnlinkedCombinatorName(builder.BuilderContext builderContext, {String name}) {
   UnlinkedCombinatorNameBuilder builder = new UnlinkedCombinatorNameBuilder(builderContext);
   builder.name = name;
   return builder;
 }
 
 class UnlinkedEnum {
   String _name;
   List<UnlinkedEnumValue> _values;
   int _unit;
 
   UnlinkedEnum.fromJson(Map json)
     : _name = json["name"],
       _values = json["values"]?.map((x) => new UnlinkedEnumValue.fromJson(x))?.toList(),
       _unit = json["unit"];
 
   String get name => _name ?? '';
   List<UnlinkedEnumValue> get values => _values ?? const <UnlinkedEnumValue>[];
   int get unit => _unit ?? 0;
 }
 
 class UnlinkedEnumBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedEnumBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set values(List<UnlinkedEnumValueBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("values"));
     if (_value != null || _value.isEmpty) {
       _json["values"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedEnumBuilder encodeUnlinkedEnum(builder.BuilderContext builderContext, {String name, List<UnlinkedEnumValueBuilder> values, int unit}) {
   UnlinkedEnumBuilder builder = new UnlinkedEnumBuilder(builderContext);
   builder.name = name;
   builder.values = values;
   builder.unit = unit;
   return builder;
 }
 
 class UnlinkedEnumValue {
   String _name;
 
   UnlinkedEnumValue.fromJson(Map json)
     : _name = json["name"];
 
   String get name => _name ?? '';
 }
 
 class UnlinkedEnumValueBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedEnumValueBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedEnumValueBuilder encodeUnlinkedEnumValue(builder.BuilderContext builderContext, {String name}) {
   UnlinkedEnumValueBuilder builder = new UnlinkedEnumValueBuilder(builderContext);
   builder.name = name;
   return builder;
 }
 
 class UnlinkedExecutable {
   String _name;
@@ skipping 30 matching lines @@
   bool get isAbstract => _isAbstract ?? false;
   bool get isStatic => _isStatic ?? false;
   bool get isConst => _isConst ?? false;
   bool get isFactory => _isFactory ?? false;
   bool get hasImplicitReturnType => _hasImplicitReturnType ?? false;
 }
 
 class UnlinkedExecutableBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedExecutableBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (_value != null || _value.isEmpty) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set returnType(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("returnType"));
     if (_value != null) {
       _json["returnType"] = _value.finish();
     }
   }
 
   void set parameters(List<UnlinkedParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("parameters"));
     if (_value != null || _value.isEmpty) {
       _json["parameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set kind(UnlinkedExecutableKind _value) {
+    assert(!_finished);
     assert(!_json.containsKey("kind"));
     if (_value != null || _value == UnlinkedExecutableKind.functionOrMethod) {
       _json["kind"] = _value.index;
     }
   }
 
   void set isAbstract(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isAbstract"));
     if (_value != null) {
       _json["isAbstract"] = _value;
     }
   }
 
   void set isStatic(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isStatic"));
     if (_value != null) {
       _json["isStatic"] = _value;
     }
   }
 
   void set isConst(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isConst"));
     if (_value != null) {
       _json["isConst"] = _value;
     }
   }
 
   void set isFactory(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isFactory"));
     if (_value != null) {
       _json["isFactory"] = _value;
     }
   }
 
   void set hasImplicitReturnType(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("hasImplicitReturnType"));
     if (_value != null) {
       _json["hasImplicitReturnType"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedExecutableBuilder encodeUnlinkedExecutable(builder.BuilderContext builderContext, {String name, int unit, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType}) {
   UnlinkedExecutableBuilder builder = new UnlinkedExecutableBuilder(builderContext);
   builder.name = name;
   builder.unit = unit;
   builder.typeParameters = typeParameters;
   builder.returnType = returnType;
   builder.parameters = parameters;
   builder.kind = kind;
@@ skipping 13 matching lines @@
     : _uri = json["uri"],
       _combinators = json["combinators"]?.map((x) => new UnlinkedCombinator.fromJson(x))?.toList();
 
   String get uri => _uri ?? '';
   List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
 }
 
 class UnlinkedExportBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedExportBuilder(builder.BuilderContext context);
 
   void set uri(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("uri"));
     if (_value != null) {
       _json["uri"] = _value;
     }
   }
 
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("combinators"));
     if (_value != null || _value.isEmpty) {
       _json["combinators"] = _value.map((b) => b.finish()).toList();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedExportBuilder encodeUnlinkedExport(builder.BuilderContext builderContext, {String uri, List<UnlinkedCombinatorBuilder> combinators}) {
   UnlinkedExportBuilder builder = new UnlinkedExportBuilder(builderContext);
   builder.uri = uri;
   builder.combinators = combinators;
   return builder;
 }
 
 class UnlinkedImport {
@@ skipping 16 matching lines @@
   int get offset => _offset ?? 0;
   int get prefix => _prefix ?? 0;
   List<UnlinkedCombinator> get combinators => _combinators ?? const <UnlinkedCombinator>[];
   bool get isDeferred => _isDeferred ?? false;
   bool get isImplicit => _isImplicit ?? false;
 }
 
 class UnlinkedImportBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedImportBuilder(builder.BuilderContext context);
 
   void set uri(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("uri"));
     if (_value != null) {
       _json["uri"] = _value;
     }
   }
 
   void set offset(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("offset"));
     if (_value != null) {
       _json["offset"] = _value;
     }
   }
 
   void set prefix(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("prefix"));
     if (_value != null) {
       _json["prefix"] = _value;
     }
   }
 
   void set combinators(List<UnlinkedCombinatorBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("combinators"));
     if (_value != null || _value.isEmpty) {
       _json["combinators"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set isDeferred(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isDeferred"));
     if (_value != null) {
       _json["isDeferred"] = _value;
     }
   }
 
   void set isImplicit(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isImplicit"));
     if (_value != null) {
       _json["isImplicit"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedImportBuilder encodeUnlinkedImport(builder.BuilderContext builderContext, {String uri, int offset, int prefix, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit}) {
   UnlinkedImportBuilder builder = new UnlinkedImportBuilder(builderContext);
   builder.uri = uri;
   builder.offset = offset;
   builder.prefix = prefix;
   builder.combinators = combinators;
   builder.isDeferred = isDeferred;
   builder.isImplicit = isImplicit;
@@ skipping 35 matching lines @@
   List<UnlinkedExport> get exports => _exports ?? const <UnlinkedExport>[];
   List<UnlinkedImport> get imports => _imports ?? const <UnlinkedImport>[];
   List<UnlinkedTypedef> get typedefs => _typedefs ?? const <UnlinkedTypedef>[];
   List<UnlinkedVariable> get variables => _variables ?? const <UnlinkedVariable>[];
   List<UnlinkedPrefix> get prefixes => _prefixes ?? const <UnlinkedPrefix>[];
 }
 
 class UnlinkedLibraryBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedLibraryBuilder(builder.BuilderContext context);
 
   void set references(List<UnlinkedReferenceBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("references"));
     if (_value != null || _value.isEmpty) {
       _json["references"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set units(List<UnlinkedUnitBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("units"));
     if (_value != null || _value.isEmpty) {
       _json["units"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set classes(List<UnlinkedClassBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("classes"));
     if (_value != null || _value.isEmpty) {
       _json["classes"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set enums(List<UnlinkedEnumBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("enums"));
     if (_value != null || _value.isEmpty) {
       _json["enums"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set executables(List<UnlinkedExecutableBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("executables"));
     if (_value != null || _value.isEmpty) {
       _json["executables"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set exports(List<UnlinkedExportBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("exports"));
     if (_value != null || _value.isEmpty) {
       _json["exports"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set imports(List<UnlinkedImportBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("imports"));
     if (_value != null || _value.isEmpty) {
       _json["imports"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set typedefs(List<UnlinkedTypedefBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("typedefs"));
     if (_value != null || _value.isEmpty) {
       _json["typedefs"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set variables(List<UnlinkedVariableBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("variables"));
     if (_value != null || _value.isEmpty) {
       _json["variables"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set prefixes(List<UnlinkedPrefixBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("prefixes"));
     if (_value != null || _value.isEmpty) {
       _json["prefixes"] = _value.map((b) => b.finish()).toList();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedLibraryBuilder encodeUnlinkedLibrary(builder.BuilderContext builderContext, {List<UnlinkedReferenceBuilder> references, List<UnlinkedUnitBuilder> units, String name, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables, List<UnlinkedPrefixBuilder> prefixes}) {
   UnlinkedLibraryBuilder builder = new UnlinkedLibraryBuilder(builderContext);
   builder.references = references;
   builder.units = units;
   builder.name = name;
   builder.classes = classes;
   builder.enums = enums;
   builder.executables = executables;
@@ skipping 28 matching lines @@
   List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
   UnlinkedParamKind get kind => _kind ?? UnlinkedParamKind.required;
   bool get isFunctionTyped => _isFunctionTyped ?? false;
   bool get isInitializingFormal => _isInitializingFormal ?? false;
   bool get hasImplicitType => _hasImplicitType ?? false;
 }
 
 class UnlinkedParamBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedParamBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set type(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("type"));
     if (_value != null) {
       _json["type"] = _value.finish();
     }
   }
 
   void set parameters(List<UnlinkedParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("parameters"));
     if (_value != null || _value.isEmpty) {
       _json["parameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set kind(UnlinkedParamKind _value) {
+    assert(!_finished);
     assert(!_json.containsKey("kind"));
     if (_value != null || _value == UnlinkedParamKind.required) {
       _json["kind"] = _value.index;
     }
   }
 
   void set isFunctionTyped(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isFunctionTyped"));
     if (_value != null) {
       _json["isFunctionTyped"] = _value;
     }
   }
 
   void set isInitializingFormal(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isInitializingFormal"));
     if (_value != null) {
       _json["isInitializingFormal"] = _value;
     }
   }
 
   void set hasImplicitType(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("hasImplicitType"));
     if (_value != null) {
       _json["hasImplicitType"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedParamBuilder encodeUnlinkedParam(builder.BuilderContext builderContext, {String name, UnlinkedTypeRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, bool hasImplicitType}) {
   UnlinkedParamBuilder builder = new UnlinkedParamBuilder(builderContext);
   builder.name = name;
   builder.type = type;
   builder.parameters = parameters;
   builder.kind = kind;
   builder.isFunctionTyped = isFunctionTyped;
   builder.isInitializingFormal = isInitializingFormal;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }
 
 class UnlinkedPrefix {
   String _name;
 
   UnlinkedPrefix.fromJson(Map json)
     : _name = json["name"];
 
   String get name => _name ?? '';
 }
 
 class UnlinkedPrefixBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedPrefixBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedPrefixBuilder encodeUnlinkedPrefix(builder.BuilderContext builderContext, {String name}) {
   UnlinkedPrefixBuilder builder = new UnlinkedPrefixBuilder(builderContext);
   builder.name = name;
   return builder;
 }
 
 class UnlinkedReference {
   String _name;
   int _prefix;
 
   UnlinkedReference.fromJson(Map json)
     : _name = json["name"],
       _prefix = json["prefix"];
 
   String get name => _name ?? '';
   int get prefix => _prefix ?? 0;
 }
 
 class UnlinkedReferenceBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedReferenceBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set prefix(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("prefix"));
     if (_value != null) {
       _json["prefix"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedReferenceBuilder encodeUnlinkedReference(builder.BuilderContext builderContext, {String name, int prefix}) {
   UnlinkedReferenceBuilder builder = new UnlinkedReferenceBuilder(builderContext);
   builder.name = name;
   builder.prefix = prefix;
   return builder;
 }
 
 class UnlinkedTypedef {
@@ skipping 13 matching lines @@
   String get name => _name ?? '';
   int get unit => _unit ?? 0;
   List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
   UnlinkedTypeRef get returnType => _returnType;
   List<UnlinkedParam> get parameters => _parameters ?? const <UnlinkedParam>[];
 }
 
 class UnlinkedTypedefBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedTypedefBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (_value != null || _value.isEmpty) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   void set returnType(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("returnType"));
     if (_value != null) {
       _json["returnType"] = _value.finish();
     }
   }
 
   void set parameters(List<UnlinkedParamBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("parameters"));
     if (_value != null || _value.isEmpty) {
       _json["parameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedTypedefBuilder encodeUnlinkedTypedef(builder.BuilderContext builderContext, {String name, int unit, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters}) {
   UnlinkedTypedefBuilder builder = new UnlinkedTypedefBuilder(builderContext);
   builder.name = name;
   builder.unit = unit;
   builder.typeParameters = typeParameters;
   builder.returnType = returnType;
   builder.parameters = parameters;
   return builder;
 }
 
 class UnlinkedTypeParam {
   String _name;
   UnlinkedTypeRef _bound;
 
   UnlinkedTypeParam.fromJson(Map json)
     : _name = json["name"],
       _bound = json["bound"] == null ? null : new UnlinkedTypeRef.fromJson(json["bound"]);
 
   String get name => _name ?? '';
   UnlinkedTypeRef get bound => _bound;
 }
 
 class UnlinkedTypeParamBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedTypeParamBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set bound(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("bound"));
     if (_value != null) {
       _json["bound"] = _value.finish();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedTypeParamBuilder encodeUnlinkedTypeParam(builder.BuilderContext builderContext, {String name, UnlinkedTypeRefBuilder bound}) {
   UnlinkedTypeParamBuilder builder = new UnlinkedTypeParamBuilder(builderContext);
   builder.name = name;
   builder.bound = bound;
   return builder;
 }
 
 class UnlinkedTypeRef {
   int _reference;
   int _paramReference;
   List<UnlinkedTypeRef> _typeArguments;
 
   UnlinkedTypeRef.fromJson(Map json)
     : _reference = json["reference"],
       _paramReference = json["paramReference"],
       _typeArguments = json["typeArguments"]?.map((x) => new UnlinkedTypeRef.fromJson(x))?.toList();
 
   int get reference => _reference ?? 0;
   int get paramReference => _paramReference ?? 0;
   List<UnlinkedTypeRef> get typeArguments => _typeArguments ?? const <UnlinkedTypeRef>[];
 }
 
 class UnlinkedTypeRefBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedTypeRefBuilder(builder.BuilderContext context);
 
   void set reference(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("reference"));
     if (_value != null) {
       _json["reference"] = _value;
     }
   }
 
   void set paramReference(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("paramReference"));
     if (_value != null) {
       _json["paramReference"] = _value;
     }
   }
 
   void set typeArguments(List<UnlinkedTypeRefBuilder> _value) {
+    assert(!_finished);
     assert(!_json.containsKey("typeArguments"));
     if (_value != null || _value.isEmpty) {
       _json["typeArguments"] = _value.map((b) => b.finish()).toList();
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedTypeRefBuilder encodeUnlinkedTypeRef(builder.BuilderContext builderContext, {int reference, int paramReference, List<UnlinkedTypeRefBuilder> typeArguments}) {
   UnlinkedTypeRefBuilder builder = new UnlinkedTypeRefBuilder(builderContext);
   builder.reference = reference;
   builder.paramReference = paramReference;
   builder.typeArguments = typeArguments;
   return builder;
 }
 
 class UnlinkedUnit {
   String _uri;
 
   UnlinkedUnit.fromJson(Map json)
     : _uri = json["uri"];
 
   String get uri => _uri ?? '';
 }
 
 class UnlinkedUnitBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedUnitBuilder(builder.BuilderContext context);
 
   void set uri(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("uri"));
     if (_value != null) {
       _json["uri"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedUnitBuilder encodeUnlinkedUnit(builder.BuilderContext builderContext, {String uri}) {
   UnlinkedUnitBuilder builder = new UnlinkedUnitBuilder(builderContext);
   builder.uri = uri;
   return builder;
 }
 
 class UnlinkedVariable {
   String _name;
@@ skipping 18 matching lines @@
   UnlinkedTypeRef get type => _type;
   bool get isStatic => _isStatic ?? false;
   bool get isFinal => _isFinal ?? false;
   bool get isConst => _isConst ?? false;
   bool get hasImplicitType => _hasImplicitType ?? false;
 }
 
 class UnlinkedVariableBuilder {
   final Map _json = {};
 
+  bool _finished = false;
+
   UnlinkedVariableBuilder(builder.BuilderContext context);
 
   void set name(String _value) {
+    assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   void set unit(int _value) {
+    assert(!_finished);
     assert(!_json.containsKey("unit"));
     if (_value != null) {
       _json["unit"] = _value;
     }
   }
 
   void set type(UnlinkedTypeRefBuilder _value) {
+    assert(!_finished);
     assert(!_json.containsKey("type"));
     if (_value != null) {
       _json["type"] = _value.finish();
     }
   }
 
   void set isStatic(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isStatic"));
     if (_value != null) {
       _json["isStatic"] = _value;
     }
   }
 
   void set isFinal(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isFinal"));
     if (_value != null) {
       _json["isFinal"] = _value;
     }
   }
 
   void set isConst(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("isConst"));
     if (_value != null) {
       _json["isConst"] = _value;
     }
   }
 
   void set hasImplicitType(bool _value) {
+    assert(!_finished);
     assert(!_json.containsKey("hasImplicitType"));
     if (_value != null) {
       _json["hasImplicitType"] = _value;
     }
   }
 
-  Map finish() => _json;
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
 }
 
 UnlinkedVariableBuilder encodeUnlinkedVariable(builder.BuilderContext builderContext, {String name, int unit, UnlinkedTypeRefBuilder type, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType}) {
   UnlinkedVariableBuilder builder = new UnlinkedVariableBuilder(builderContext);
   builder.name = name;
   builder.unit = unit;
   builder.type = type;
   builder.isStatic = isStatic;
   builder.isFinal = isFinal;
   builder.isConst = isConst;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }