Organize summary declarations by unit rather than by library.

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 50 matching lines @@
   }
 }
 
 PrelinkedDependencyBuilder encodePrelinkedDependency(builder.BuilderContext builderContext, {String uri}) {
   PrelinkedDependencyBuilder builder = new PrelinkedDependencyBuilder(builderContext);
   builder.uri = uri;
   return builder;
 }
 
 class PrelinkedLibrary {
+  List<PrelinkedUnit> _units;
   UnlinkedLibrary _unlinked;
   List<PrelinkedDependency> _dependencies;
   List<int> _importDependencies;
   List<PrelinkedReference> _references;
 
   PrelinkedLibrary.fromJson(Map json)
-    : _unlinked = json["unlinked"] == null ? null : new UnlinkedLibrary.fromJson(json["unlinked"]),
+    : _units = json["units"]?.map((x) => new PrelinkedUnit.fromJson(x))?.toList(),
+      _unlinked = json["unlinked"] == null ? null : new UnlinkedLibrary.fromJson(json["unlinked"]),
       _dependencies = json["dependencies"]?.map((x) => new PrelinkedDependency.fromJson(x))?.toList(),
       _importDependencies = json["importDependencies"],
       _references = json["references"]?.map((x) => new PrelinkedReference.fromJson(x))?.toList();
 
   PrelinkedLibrary.fromBuffer(List<int> buffer) : this.fromJson(JSON.decode(UTF8.decode(buffer)));
 
+  List<PrelinkedUnit> get units => _units ?? const <PrelinkedUnit>[];
   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 units(List<PrelinkedUnitBuilder> _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("units"));
+    if (_value != null || _value.isEmpty) {
+      _json["units"] = _value.map((b) => b.finish()).toList();
+    }
+  }
+
   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);
@@ skipping 21 matching lines @@
 
   List<int> toBuffer() => UTF8.encode(JSON.encode(finish()));
 
   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 encodePrelinkedLibrary(builder.BuilderContext builderContext, {List<PrelinkedUnitBuilder> units, UnlinkedLibraryBuilder unlinked, List<PrelinkedDependencyBuilder> dependencies, List<int> importDependencies, List<PrelinkedReferenceBuilder> references}) {
   PrelinkedLibraryBuilder builder = new PrelinkedLibraryBuilder(builderContext);
+  builder.units = units;
   builder.unlinked = unlinked;
   builder.dependencies = dependencies;
   builder.importDependencies = importDependencies;
   builder.references = references;
   return builder;
 }
 
 class PrelinkedReference {
   int _dependency;
   PrelinkedReferenceKind _kind;
@@ skipping 48 matching lines @@
 }
 
 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;
 }
 
+class PrelinkedUnit {
+  UnlinkedUnit _unlinked;
+
+  PrelinkedUnit.fromJson(Map json)
+    : _unlinked = json["unlinked"] == null ? null : new UnlinkedUnit.fromJson(json["unlinked"]);
+
+  UnlinkedUnit get unlinked => _unlinked;
+}
+
+class PrelinkedUnitBuilder {
+  final Map _json = {};
+
+  bool _finished = false;
+
+  PrelinkedUnitBuilder(builder.BuilderContext context);
+
+  void set unlinked(UnlinkedUnitBuilder _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("unlinked"));
+    if (_value != null) {
+      _json["unlinked"] = _value.finish();
+    }
+  }
+
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
+}
+
+PrelinkedUnitBuilder encodePrelinkedUnit(builder.BuilderContext builderContext, {UnlinkedUnitBuilder unlinked}) {
+  PrelinkedUnitBuilder builder = new PrelinkedUnitBuilder(builderContext);
+  builder.unlinked = unlinked;
+  return builder;
+}
+
 class UnlinkedClass {
   String _name;
-  int _unit;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _supertype;
   List<UnlinkedTypeRef> _mixins;
   List<UnlinkedTypeRef> _interfaces;
   List<UnlinkedVariable> _fields;
   List<UnlinkedExecutable> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
 
   UnlinkedClass.fromJson(Map json)
     : _name = json["name"],
-      _unit = json["unit"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _supertype = json["supertype"] == null ? null : new UnlinkedTypeRef.fromJson(json["supertype"]),
       _mixins = json["mixins"]?.map((x) => new UnlinkedTypeRef.fromJson(x))?.toList(),
       _interfaces = json["interfaces"]?.map((x) => new UnlinkedTypeRef.fromJson(x))?.toList(),
       _fields = json["fields"]?.map((x) => new UnlinkedVariable.fromJson(x))?.toList(),
       _executables = json["executables"]?.map((x) => new UnlinkedExecutable.fromJson(x))?.toList(),
       _isAbstract = json["isAbstract"],
       _isMixinApplication = json["isMixinApplication"];
 
   String get name => _name ?? '';
-  int get unit => _unit ?? 0;
   List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
   UnlinkedTypeRef get supertype => _supertype;
   List<UnlinkedTypeRef> get mixins => _mixins ?? const <UnlinkedTypeRef>[];
   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);
@@ skipping 51 matching lines @@
     }
   }
 
   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 encodeUnlinkedClass(builder.BuilderContext builderContext, {String name, 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;
   builder.fields = fields;
   builder.executables = executables;
   builder.isAbstract = isAbstract;
   builder.isMixinApplication = isMixinApplication;
   return builder;
 }
@@ skipping 80 matching lines @@
 
 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"];
+      _values = json["values"]?.map((x) => new UnlinkedEnumValue.fromJson(x))?.toList();
 
   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() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedEnumBuilder encodeUnlinkedEnum(builder.BuilderContext builderContext, {String name, List<UnlinkedEnumValueBuilder> values, int unit}) {
+UnlinkedEnumBuilder encodeUnlinkedEnum(builder.BuilderContext builderContext, {String name, List<UnlinkedEnumValueBuilder> values}) {
   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 ?? '';
@@ skipping 22 matching lines @@
 }
 
 UnlinkedEnumValueBuilder encodeUnlinkedEnumValue(builder.BuilderContext builderContext, {String name}) {
   UnlinkedEnumValueBuilder builder = new UnlinkedEnumValueBuilder(builderContext);
   builder.name = name;
   return builder;
 }
 
 class UnlinkedExecutable {
   String _name;
-  int _unit;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
 
   UnlinkedExecutable.fromJson(Map json)
     : _name = json["name"],
-      _unit = json["unit"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _returnType = json["returnType"] == null ? null : new UnlinkedTypeRef.fromJson(json["returnType"]),
       _parameters = json["parameters"]?.map((x) => new UnlinkedParam.fromJson(x))?.toList(),
       _kind = json["kind"] == null ? null : UnlinkedExecutableKind.values[json["kind"]],
       _isAbstract = json["isAbstract"],
       _isStatic = json["isStatic"],
       _isConst = json["isConst"],
       _isFactory = json["isFactory"],
       _hasImplicitReturnType = json["hasImplicitReturnType"];
 
   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>[];
   UnlinkedExecutableKind get kind => _kind ?? UnlinkedExecutableKind.functionOrMethod;
   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);
@@ skipping 59 matching lines @@
     }
   }
 
   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 encodeUnlinkedExecutable(builder.BuilderContext builderContext, {String name, 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;
   builder.isAbstract = isAbstract;
   builder.isStatic = isStatic;
   builder.isConst = isConst;
   builder.isFactory = isFactory;
   builder.hasImplicitReturnType = hasImplicitReturnType;
   return builder;
@@ skipping 140 matching lines @@
   builder.offset = offset;
   builder.prefix = prefix;
   builder.combinators = combinators;
   builder.isDeferred = isDeferred;
   builder.isImplicit = isImplicit;
   return builder;
 }
 
 class UnlinkedLibrary {
   List<UnlinkedReference> _references;
-  List<UnlinkedUnit> _units;
-  String _name;
-  List<UnlinkedClass> _classes;
-  List<UnlinkedEnum> _enums;
-  List<UnlinkedExecutable> _executables;
-  List<UnlinkedExport> _exports;
-  List<UnlinkedImport> _imports;
-  List<UnlinkedTypedef> _typedefs;
-  List<UnlinkedVariable> _variables;
   List<UnlinkedPrefix> _prefixes;
 
   UnlinkedLibrary.fromJson(Map json)
     : _references = json["references"]?.map((x) => new UnlinkedReference.fromJson(x))?.toList(),
-      _units = json["units"]?.map((x) => new UnlinkedUnit.fromJson(x))?.toList(),
-      _name = json["name"],
-      _classes = json["classes"]?.map((x) => new UnlinkedClass.fromJson(x))?.toList(),
-      _enums = json["enums"]?.map((x) => new UnlinkedEnum.fromJson(x))?.toList(),
-      _executables = json["executables"]?.map((x) => new UnlinkedExecutable.fromJson(x))?.toList(),
-      _exports = json["exports"]?.map((x) => new UnlinkedExport.fromJson(x))?.toList(),
-      _imports = json["imports"]?.map((x) => new UnlinkedImport.fromJson(x))?.toList(),
-      _typedefs = json["typedefs"]?.map((x) => new UnlinkedTypedef.fromJson(x))?.toList(),
-      _variables = json["variables"]?.map((x) => new UnlinkedVariable.fromJson(x))?.toList(),
       _prefixes = json["prefixes"]?.map((x) => new UnlinkedPrefix.fromJson(x))?.toList();
 
   List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
-  List<UnlinkedUnit> get units => _units ?? const <UnlinkedUnit>[];
-  String get name => _name ?? '';
-  List<UnlinkedClass> get classes => _classes ?? const <UnlinkedClass>[];
-  List<UnlinkedEnum> get enums => _enums ?? const <UnlinkedEnum>[];
-  List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
-  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() {
     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 encodeUnlinkedLibrary(builder.BuilderContext builderContext, {List<UnlinkedReferenceBuilder> references, 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;
-  builder.exports = exports;
-  builder.imports = imports;
-  builder.typedefs = typedefs;
-  builder.variables = variables;
   builder.prefixes = prefixes;
   return builder;
 }
 
 class UnlinkedParam {
   String _name;
   UnlinkedTypeRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
@@ skipping 93 matching lines @@
   builder.name = name;
   builder.type = type;
   builder.parameters = parameters;
   builder.kind = kind;
   builder.isFunctionTyped = isFunctionTyped;
   builder.isInitializingFormal = isInitializingFormal;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }
 
+class UnlinkedPart {
+  String _uri;
+
+  UnlinkedPart.fromJson(Map json)
+    : _uri = json["uri"];
+
+  String get uri => _uri ?? '';
+}
+
+class UnlinkedPartBuilder {
+  final Map _json = {};
+
+  bool _finished = false;
+
+  UnlinkedPartBuilder(builder.BuilderContext context);
+
+  void set uri(String _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("uri"));
+    if (_value != null) {
+      _json["uri"] = _value;
+    }
+  }
+
+  Map finish() {
+    assert(!_finished);
+    _finished = true;
+    return _json;
+  }
+}
+
+UnlinkedPartBuilder encodeUnlinkedPart(builder.BuilderContext builderContext, {String uri}) {
+  UnlinkedPartBuilder builder = new UnlinkedPartBuilder(builderContext);
+  builder.uri = uri;
+  return builder;
+}
+
 class UnlinkedPrefix {
   String _name;
 
   UnlinkedPrefix.fromJson(Map json)
     : _name = json["name"];
 
   String get name => _name ?? '';
 }
 
 class UnlinkedPrefixBuilder {
@@ skipping 68 matching lines @@
 
 UnlinkedReferenceBuilder encodeUnlinkedReference(builder.BuilderContext builderContext, {String name, int prefix}) {
   UnlinkedReferenceBuilder builder = new UnlinkedReferenceBuilder(builderContext);
   builder.name = name;
   builder.prefix = prefix;
   return builder;
 }
 
 class UnlinkedTypedef {
   String _name;
-  int _unit;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
 
   UnlinkedTypedef.fromJson(Map json)
     : _name = json["name"],
-      _unit = json["unit"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _returnType = json["returnType"] == null ? null : new UnlinkedTypeRef.fromJson(json["returnType"]),
       _parameters = json["parameters"]?.map((x) => new UnlinkedParam.fromJson(x))?.toList();
 
   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);
@@ skipping 11 matching lines @@
     }
   }
 
   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 encodeUnlinkedTypedef(builder.BuilderContext builderContext, {String name, 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;
 
@@ skipping 97 matching lines @@
 
 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;
+  String _libraryName;
+  List<UnlinkedClass> _classes;
+  List<UnlinkedEnum> _enums;
+  List<UnlinkedExecutable> _executables;
+  List<UnlinkedExport> _exports;
+  List<UnlinkedImport> _imports;
+  List<UnlinkedPart> _parts;
+  List<UnlinkedTypedef> _typedefs;
+  List<UnlinkedVariable> _variables;
 
   UnlinkedUnit.fromJson(Map json)
-    : _uri = json["uri"];
+    : _libraryName = json["libraryName"],
+      _classes = json["classes"]?.map((x) => new UnlinkedClass.fromJson(x))?.toList(),
+      _enums = json["enums"]?.map((x) => new UnlinkedEnum.fromJson(x))?.toList(),
+      _executables = json["executables"]?.map((x) => new UnlinkedExecutable.fromJson(x))?.toList(),
+      _exports = json["exports"]?.map((x) => new UnlinkedExport.fromJson(x))?.toList(),
+      _imports = json["imports"]?.map((x) => new UnlinkedImport.fromJson(x))?.toList(),
+      _parts = json["parts"]?.map((x) => new UnlinkedPart.fromJson(x))?.toList(),
+      _typedefs = json["typedefs"]?.map((x) => new UnlinkedTypedef.fromJson(x))?.toList(),
+      _variables = json["variables"]?.map((x) => new UnlinkedVariable.fromJson(x))?.toList();
 
-  String get uri => _uri ?? '';
+  String get libraryName => _libraryName ?? '';
+  List<UnlinkedClass> get classes => _classes ?? const <UnlinkedClass>[];
+  List<UnlinkedEnum> get enums => _enums ?? const <UnlinkedEnum>[];
+  List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
+  List<UnlinkedExport> get exports => _exports ?? const <UnlinkedExport>[];
+  List<UnlinkedImport> get imports => _imports ?? const <UnlinkedImport>[];
+  List<UnlinkedPart> get parts => _parts ?? const <UnlinkedPart>[];
+  List<UnlinkedTypedef> get typedefs => _typedefs ?? const <UnlinkedTypedef>[];
+  List<UnlinkedVariable> get variables => _variables ?? const <UnlinkedVariable>[];
 }
 
 class UnlinkedUnitBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedUnitBuilder(builder.BuilderContext context);
 
-  void set uri(String _value) {
+  void set libraryName(String _value) {
     assert(!_finished);
-    assert(!_json.containsKey("uri"));
+    assert(!_json.containsKey("libraryName"));
     if (_value != null) {
-      _json["uri"] = _value;
+      _json["libraryName"] = _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 parts(List<UnlinkedPartBuilder> _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("parts"));
+    if (_value != null || _value.isEmpty) {
+      _json["parts"] = _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();
+    }
+  }
+
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedUnitBuilder encodeUnlinkedUnit(builder.BuilderContext builderContext, {String uri}) {
+UnlinkedUnitBuilder encodeUnlinkedUnit(builder.BuilderContext builderContext, {String libraryName, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables}) {
   UnlinkedUnitBuilder builder = new UnlinkedUnitBuilder(builderContext);
-  builder.uri = uri;
+  builder.libraryName = libraryName;
+  builder.classes = classes;
+  builder.enums = enums;
+  builder.executables = executables;
+  builder.exports = exports;
+  builder.imports = imports;
+  builder.parts = parts;
+  builder.typedefs = typedefs;
+  builder.variables = variables;
   return builder;
 }
 
 class UnlinkedVariable {
   String _name;
-  int _unit;
   UnlinkedTypeRef _type;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
 
   UnlinkedVariable.fromJson(Map json)
     : _name = json["name"],
-      _unit = json["unit"],
       _type = json["type"] == null ? null : new UnlinkedTypeRef.fromJson(json["type"]),
       _isStatic = json["isStatic"],
       _isFinal = json["isFinal"],
       _isConst = json["isConst"],
       _hasImplicitType = json["hasImplicitType"];
 
   String get name => _name ?? '';
-  int get unit => _unit ?? 0;
   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);
@@ skipping 27 matching lines @@
     }
   }
 
   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 encodeUnlinkedVariable(builder.BuilderContext builderContext, {String name, 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;
 }