Move summary references into UnlinkedUnit and PrelinkedUnit.

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 54 matching lines @@
   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)
     : _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();
+      _importDependencies = json["importDependencies"];
 
   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) {
@@ skipping 21 matching lines @@
   }
 
   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() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-PrelinkedLibraryBuilder encodePrelinkedLibrary(builder.BuilderContext builderContext, {List<PrelinkedUnitBuilder> units, 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}) {
   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;
   int _unit;
 
   PrelinkedReference.fromJson(Map json)
     : _dependency = json["dependency"],
@@ skipping 46 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;
+  List<PrelinkedReference> _references;
 
   PrelinkedUnit.fromJson(Map json)
-    : _unlinked = json["unlinked"] == null ? null : new UnlinkedUnit.fromJson(json["unlinked"]);
+    : _unlinked = json["unlinked"] == null ? null : new UnlinkedUnit.fromJson(json["unlinked"]),
+      _references = json["references"]?.map((x) => new PrelinkedReference.fromJson(x))?.toList();
 
   UnlinkedUnit get unlinked => _unlinked;
+  List<PrelinkedReference> get references => _references ?? const <PrelinkedReference>[];
 }
 
 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();
     }
   }
 
+  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();
+    }
+  }
+
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-PrelinkedUnitBuilder encodePrelinkedUnit(builder.BuilderContext builderContext, {UnlinkedUnitBuilder unlinked}) {
+PrelinkedUnitBuilder encodePrelinkedUnit(builder.BuilderContext builderContext, {UnlinkedUnitBuilder unlinked, List<PrelinkedReferenceBuilder> references}) {
   PrelinkedUnitBuilder builder = new PrelinkedUnitBuilder(builderContext);
   builder.unlinked = unlinked;
+  builder.references = references;
   return builder;
 }
 
 class UnlinkedClass {
   String _name;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _supertype;
   List<UnlinkedTypeRef> _mixins;
   List<UnlinkedTypeRef> _interfaces;
   List<UnlinkedVariable> _fields;
@@ skipping 580 matching lines @@
   builder.uri = uri;
   builder.offset = offset;
   builder.prefix = prefix;
   builder.combinators = combinators;
   builder.isDeferred = isDeferred;
   builder.isImplicit = isImplicit;
   return builder;
 }
 
 class UnlinkedLibrary {
-  List<UnlinkedReference> _references;
   List<UnlinkedPrefix> _prefixes;
 
   UnlinkedLibrary.fromJson(Map json)
-    : _references = json["references"]?.map((x) => new UnlinkedReference.fromJson(x))?.toList(),
-      _prefixes = json["prefixes"]?.map((x) => new UnlinkedPrefix.fromJson(x))?.toList();
+    : _prefixes = json["prefixes"]?.map((x) => new UnlinkedPrefix.fromJson(x))?.toList();
 
-  List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
   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 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<UnlinkedPrefixBuilder> prefixes}) {
+UnlinkedLibraryBuilder encodeUnlinkedLibrary(builder.BuilderContext builderContext, {List<UnlinkedPrefixBuilder> prefixes}) {
   UnlinkedLibraryBuilder builder = new UnlinkedLibraryBuilder(builderContext);
-  builder.references = references;
   builder.prefixes = prefixes;
   return builder;
 }
 
 class UnlinkedParam {
   String _name;
   UnlinkedTypeRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
@@ skipping 401 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 _libraryName;
+  List<UnlinkedReference> _references;
   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)
     : _libraryName = json["libraryName"],
+      _references = json["references"]?.map((x) => new UnlinkedReference.fromJson(x))?.toList(),
       _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 libraryName => _libraryName ?? '';
+  List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
   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 libraryName(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("libraryName"));
     if (_value != null) {
       _json["libraryName"] = _value;
     }
   }
 
+  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 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);
@@ skipping 51 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-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 encodeUnlinkedUnit(builder.BuilderContext builderContext, {String libraryName, List<UnlinkedReferenceBuilder> references, 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.libraryName = libraryName;
+  builder.references = references;
   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;
 }
@@ skipping 88 matching lines @@
   UnlinkedVariableBuilder builder = new UnlinkedVariableBuilder(builderContext);
   builder.name = name;
   builder.type = type;
   builder.isStatic = isStatic;
   builder.isFinal = isFinal;
   builder.isConst = isConst;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }