Separate prelinked and unlinked parts of summaries.

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';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/builder.dart';
 import 'package:analyzer/src/summary/format.dart';
 
 /**
  * Serialize all the elements in [lib] to a summary using [ctx] as the context
  * for building the summary, and using [typeProvider] to find built-in types.
  */
-PrelinkedLibraryBuilder serializeLibrary(
+LibrarySerializationResult serializeLibrary(
     BuilderContext ctx, LibraryElement lib, TypeProvider typeProvider) {
-  return new _LibrarySerializer(ctx, lib, typeProvider).serializeLibrary();
+  var serializer = new _LibrarySerializer(ctx, lib, typeProvider);
+  PrelinkedLibraryBuilder prelinked = serializer.serializeLibrary();
+  return new LibrarySerializationResult(
+      prelinked, serializer.unlinkedUnits, serializer.unitUris);
 }
 
 /**
+ * Data structure holding the result of serializing a [LibraryElement].
+ */
+class LibrarySerializationResult {
+  /**
+   * Pre-linked information the given library.
+   */
+  final PrelinkedLibraryBuilder prelinked;
+
+  /**
+   * Unlinked information for the compilation units constituting the library.
+   * The zeroth entry in the list is the defining compilation unit; the
+   * remaining entries are the parts, in the order listed in the defining
+   * compilation unit's part declarations.
+   */
+  final List<UnlinkedUnitBuilder> unlinkedUnits;
+
+  /**
+   * Absolute URI of each compilation unit appearing in the library.
+   */
+  final List<String> unitUris;
+
+  LibrarySerializationResult(this.prelinked, this.unlinkedUnits, this.unitUris);
+}
+
+/**
  * Instances of this class keep track of intermediate state during
  * serialization of a single library.`
  */
 class _LibrarySerializer {
   /**
    * The library to be serialized.
    */
   final LibraryElement libraryElement;
 
   /**
    * The type provider.  This is used to locate the library for `dart:core`.
    */
   final TypeProvider typeProvider;
 
   /**
    * List of objects which should be written to [PrelinkedLibrary.units].
    */
-  final List<PrelinkedUnitBuilder> units = <PrelinkedUnitBuilder>[];
+  final List<PrelinkedUnitBuilder> prelinkedUnits = <PrelinkedUnitBuilder>[];
+
+  /**
+   * List of unlinked units corresponding to the pre-linked units in
+   * [prelinkedUnits],
+   */
+  final List<UnlinkedUnitBuilder> unlinkedUnits = <UnlinkedUnitBuilder>[];
+
+  /**
+   * List of absolute URIs of the compilation units in the library.
+   */
+  final List<String> unitUris = <String>[];
 
   /**
    * Map from [LibraryElement] to the index of the entry in the "dependency
    * table" that refers to it.
    */
   final Map<LibraryElement, int> dependencyMap = <LibraryElement, int>{};
 
   /**
    * The "dependency table".  This is the list of objects which should be
    * written to [PrelinkedLibrary.dependencies].
@@ skipping 103 matching lines @@
       if (accessor.isSynthetic && accessor.isGetter) {
         PropertyInducingElement variable = accessor.variable;
         if (variable != null) {
           assert(!variable.isSynthetic);
           variables.add(serializeVariable(variable));
         }
       }
     }
     b.variables = variables;
     b.references = unlinkedReferences;
-    units.add(
-        encodePrelinkedUnit(ctx, unlinked: b, references: prelinkedReferences));
+    unlinkedUnits.add(b);
+    prelinkedUnits
+        .add(encodePrelinkedUnit(ctx, references: prelinkedReferences));
+    unitUris.add(element.source.uri.toString());
     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)) {
@@ skipping 202 matching lines @@
       b.uri = importElement.uri;
     }
     addTransitiveExportClosure(importElement.importedLibrary);
     prelinkedImports.add(serializeDependency(importElement.importedLibrary));
     return b;
   }
 
   /**
    * Serialize the whole library element into a [PrelinkedLibrary].  Should be
    * called exactly once for each instance of [_LibrarySerializer].
+   *
+   * The unlinked compilation units are stored in [unlinkedUnits], and their
+   * absolute URIs are stored in [unitUris].
    */
   PrelinkedLibraryBuilder serializeLibrary() {
     PrelinkedLibraryBuilder pb = new PrelinkedLibraryBuilder(ctx);
     addCompilationUnitElements(libraryElement.definingCompilationUnit, 0);
     for (int i = 0; i < libraryElement.parts.length; i++) {
       addCompilationUnitElements(libraryElement.parts[i], i + 1);
     }
-    pb.units = units;
+    pb.units = prelinkedUnits;
     pb.dependencies = dependencies;
     pb.importDependencies = prelinkedImports;
     return pb;
   }
 
   /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParam(ParameterElement parameter) {
     UnlinkedParamBuilder b = new UnlinkedParamBuilder(ctx);
@@ skipping 148 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;
   }
 }