Move summary references into UnlinkedUnit and PrelinkedUnit.

pkg/analyzer/lib/src/summary/summarize_elements.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.
 
 library serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 62 matching lines @@
   final List<UnlinkedPrefixBuilder> prefixes = <UnlinkedPrefixBuilder>[];
 
   /**
    * Map from [Element] to the index of the entry in the "references table"
    * that refers to it.
    */
   final Map<Element, int> referenceMap = <Element, int>{};
 
   /**
    * The unlinked portion of the "references table".  This is the list of
-   * objects which should be written to [UnlinkedLibrary.references].
+   * objects which should be written to [UnlinkedUnit.references].
    */
-  final List<UnlinkedReferenceBuilder> unlinkedReferences =
-      <UnlinkedReferenceBuilder>[];
+  List<UnlinkedReferenceBuilder> unlinkedReferences;
 
   /**
    * The prelinked portion of the "references table".  This is the list of
-   * objects which should be written to [PrelinkedLibrary.references].
+   * objects which should be written to [PrelinkedUnit.references].
    */
-  final List<PrelinkedReferenceBuilder> prelinkedReferences =
-      <PrelinkedReferenceBuilder>[];
+  List<PrelinkedReferenceBuilder> prelinkedReferences;
 
   //final Map<String, int> prefixIndices = <String, int>{};
 
   /**
    * Index into the "references table" representing `dynamic`, if such an index
    * exists.  `null` if no such entry has been made in the references table
    * yet.
    */
   int dynamicReferenceIndex = null;
 
@@ skipping 45 matching lines @@
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
       }
       b.exports = libraryElement.exports.map(serializeExport).toList();
       b.imports = libraryElement.imports.map(serializeImport).toList();
       b.parts = libraryElement.parts
           .map(
               (CompilationUnitElement e) => encodeUnlinkedPart(ctx, uri: e.uri))
           .toList();
     }
+    unlinkedReferences = <UnlinkedReferenceBuilder>[];
+    prelinkedReferences = <PrelinkedReferenceBuilder>[];
     b.classes = element.types.map(serializeClass).toList();
     b.enums = element.enums.map(serializeEnum).toList();
     b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
         element.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in element.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
     }
     b.executables = executables;
     List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
     for (PropertyAccessorElement accessor in element.accessors) {
       if (accessor.isSynthetic && accessor.isGetter) {
         PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           assert(!variable.isSynthetic);
           variables.add(serializeVariable(variable));
         }
       }
     }
     b.variables = variables;
-    units.add(encodePrelinkedUnit(ctx, unlinked: b));
+    b.references = unlinkedReferences;
+    units.add(
+        encodePrelinkedUnit(ctx, unlinked: b, references: prelinkedReferences));
+    unlinkedReferences = null;
+    prelinkedReferences = null;
   }
 
   /**
    * Add [exportedLibrary] (and the transitive closure of all libraries it
    * exports) to the dependency table ([PrelinkedLibrary.dependencies]).
    */
   void addTransitiveExportClosure(LibraryElement exportedLibrary) {
     if (librariesAddedToTransitiveExportClosure.add(exportedLibrary)) {
       serializeDependency(exportedLibrary);
       for (LibraryElement transitiveExport
@@ skipping 221 matching lines @@
    * called exactly once for each instance of [_LibrarySerializer].
    */
   PrelinkedLibraryBuilder serializeLibrary() {
     UnlinkedLibraryBuilder ub = new UnlinkedLibraryBuilder(ctx);
     PrelinkedLibraryBuilder pb = new PrelinkedLibraryBuilder(ctx);
     addCompilationUnitElements(libraryElement.definingCompilationUnit, 0);
     for (int i = 0; i < libraryElement.parts.length; i++) {
       addCompilationUnitElements(libraryElement.parts[i], i + 1);
     }
     ub.prefixes = prefixes;
-    ub.references = unlinkedReferences;
     pb.units = units;
     pb.unlinked = ub;
     pb.dependencies = dependencies;
     pb.importDependencies = prelinkedImports;
-    pb.references = prelinkedReferences;
     return pb;
   }
 
   /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParam(ParameterElement parameter) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder(ctx);
     b.name = parameter.name;
     switch (parameter.parameterKind) {
@@ skipping 132 matching lines @@
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     return b;
   }
 }