Split _LibrarySerializer into two classes.

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/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 import 'package:analyzer/src/summary/summarize_const_expr.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.
  */
 LibrarySerializationResult serializeLibrary(
     LibraryElement lib, TypeProvider typeProvider) {
   var serializer = new _LibrarySerializer(lib, typeProvider);
   LinkedLibraryBuilder linked = serializer.serializeLibrary();
   return new LibrarySerializationResult(
       linked, serializer.unlinkedUnits, serializer.unitUris);
 }
 
+ReferenceKind _getReferenceKind(Element element) {
+  ReferenceKind kind;
+  if (element is PropertyAccessorElement) {
+    kind = ReferenceKind.topLevelPropertyAccessor;
+  } else if (element is FunctionTypeAliasElement) {
+    kind = ReferenceKind.typedef;
+  } else if (element is ClassElement) {
+    kind = ReferenceKind.classOrEnum;
+  } else if (element is FunctionElement) {
+    kind = ReferenceKind.topLevelFunction;
+  } else {
+    throw new Exception('Unexpected element kind: ${element.runtimeType}');
+  }
+  return kind;
+}
+
 /**
  * Data structure holding the result of serializing a [LibraryElement].
  */
 class LibrarySerializationResult {
   /**
    * Linked information the given library.
    */
   final LinkedLibraryBuilder linked;
 
   /**
    * 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.linked, this.unlinkedUnits, this.unitUris);
 }
 
 /**
  * Instances of this class keep track of intermediate state during
- * serialization of a single constant [Expression].
+ * serialization of a single compilation unit.
  */
-class _ConstExprSerializer extends AbstractConstExprSerializer {
-  final _LibrarySerializer serializer;
+class _CompilationUnitSerializer {
+  /**
+   * The [_LibrarySerializer] which is serializing the library of which
+   * [compilationUnit] is a part.
+   */
+  final _LibrarySerializer librarySerializer;
 
-  _ConstExprSerializer(this.serializer);
+  /**
+   * The [CompilationUnitElement] being serialized.
+   */
+  final CompilationUnitElement compilationUnit;
 
-  TypeRefBuilder serializeIdentifier(Identifier identifier) {
-    Element element = identifier.staticElement;
-    assert(element != null);
-    // TODO(scheglov) how to serialize element references?
-    return new TypeRefBuilder(
-        reference: serializer._getElementReferenceId(element));
-  }
+  /**
+   * The ordinal index of [compilationUnit] within the library, where 0
+   * represents the defining compilation unit.
+   */
+  final int unitNum;
 
-  @override
-  TypeRefBuilder serializeType(TypeName typeName) {
-    DartType type = typeName != null ? typeName.type : DynamicTypeImpl.instance;
-    return serializer.serializeTypeRef(type, null);
-  }
-}
+  /**
+   * The final linked summary of the compilation unit.
+   */
+  final LinkedUnitBuilder linkedUnit = new LinkedUnitBuilder();
+
+  /**
+   * The final unlinked summary of the compilation unit.
+   */
+  final UnlinkedUnitBuilder unlinkedUnit = new UnlinkedUnitBuilder();
 
 /**
- * Instances of this class keep track of intermediate state during
- * serialization of a single library.
+ * Absolute URI of the compilation unit.
  */
-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 [LinkedLibrary.units].
-   */
-  final List<LinkedUnitBuilder> linkedUnits = <LinkedUnitBuilder>[];
-
-  /**
-   * List of unlinked units corresponding to the linked units in
-   * [linkedUnits],
-   */
-  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 [LinkedLibrary.dependencies].
-   */
-  final List<LinkedDependencyBuilder> dependencies =
-      <LinkedDependencyBuilder>[];
-
-  /**
-   * The linked portion of the "imports table".  This is the list of ints
-   * which should be written to [LinkedLibrary.imports].
-   */
-  final List<int> linkedImports = <int>[];
+  String unitUri;
 
   /**
    * 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 [UnlinkedUnit.references].
    */
   List<UnlinkedReferenceBuilder> unlinkedReferences;
 
   /**
    * The linked portion of the "references table".  This is the list of
    * objects which should be written to [LinkedUnit.references].
    */
   List<LinkedReferenceBuilder> linkedReferences;
 
-  //final Map<String, int> prefixIndices = <String, int>{};
-
   /**
    * Index into the "references table" representing an unresolved reference, if
    * such an index exists.  `null` if no such entry has been made in the
    * references table yet.
    */
   int unresolvedReferenceIndex = null;
 
-  /**
-   * Set of libraries which have been seen so far while visiting the transitive
-   * closure of exports.
-   */
-  final Set<LibraryElement> librariesAddedToTransitiveExportClosure =
-      new Set<LibraryElement>();
-
-  /**
-   * Map from imported element to the prefix which may be used to refer to that
-   * element; elements for which no prefix is needed are absent from this map.
-   */
-  final Map<Element, PrefixElement> prefixMap = <Element, PrefixElement>{};
-
-  _LibrarySerializer(this.libraryElement, this.typeProvider) {
-    dependencies.add(new LinkedDependencyBuilder());
-    dependencyMap[libraryElement] = 0;
-  }
-
-  /**
-   * Retrieve the library element for `dart:core`.
-   */
-  LibraryElement get coreLibrary => typeProvider.objectType.element.library;
+  _CompilationUnitSerializer(
+      this.librarySerializer, this.compilationUnit, this.unitNum);
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
-   * from the given compilation unit [element] to the library summary.
+   * from the given compilation unit [element] to the compilation unit summary.
    * [unitNum] indicates the ordinal position of this compilation unit in the
    * library.
    */
-  void addCompilationUnitElements(CompilationUnitElement element, int unitNum) {
-    UnlinkedUnitBuilder b = new UnlinkedUnitBuilder();
-    referenceMap.clear();
+  void addCompilationUnitElements() {
     unlinkedReferences = <UnlinkedReferenceBuilder>[
       new UnlinkedReferenceBuilder()
     ];
     linkedReferences = <LinkedReferenceBuilder>[
       new LinkedReferenceBuilder(kind: ReferenceKind.classOrEnum)
     ];
     List<UnlinkedPublicNameBuilder> names = <UnlinkedPublicNameBuilder>[];
-    for (PropertyAccessorElement accessor in element.accessors) {
+    for (PropertyAccessorElement accessor in compilationUnit.accessors) {
       if (accessor.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
             kind: ReferenceKind.topLevelPropertyAccessor,
             name: accessor.name,
             numTypeParameters: accessor.typeParameters.length));
       }
     }
-    for (ClassElement cls in element.types) {
+    for (ClassElement cls in compilationUnit.types) {
       if (cls.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
             kind: ReferenceKind.classOrEnum,
             name: cls.name,
             numTypeParameters: cls.typeParameters.length));
       }
     }
-    for (ClassElement enm in element.enums) {
+    for (ClassElement enm in compilationUnit.enums) {
       if (enm.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
             kind: ReferenceKind.classOrEnum, name: enm.name));
       }
     }
-    for (FunctionElement function in element.functions) {
+    for (FunctionElement function in compilationUnit.functions) {
       if (function.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
             kind: ReferenceKind.topLevelFunction,
             name: function.name,
             numTypeParameters: function.typeParameters.length));
       }
     }
-    for (FunctionTypeAliasElement typedef in element.functionTypeAliases) {
+    for (FunctionTypeAliasElement typedef
+        in compilationUnit.functionTypeAliases) {
       if (typedef.isPublic) {
         names.add(new UnlinkedPublicNameBuilder(
             kind: ReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
+      LibraryElement libraryElement = librarySerializer.libraryElement;
       if (libraryElement.name.isNotEmpty) {
-        b.libraryName = libraryElement.name;
-        b.libraryNameOffset = libraryElement.nameOffset;
-        b.libraryNameLength = libraryElement.nameLength;
-        b.libraryDocumentationComment = serializeDocumentation(libraryElement);
+        LibraryElement libraryElement = librarySerializer.libraryElement;
+        unlinkedUnit.libraryName = libraryElement.name;
+        unlinkedUnit.libraryNameOffset = libraryElement.nameOffset;
+        unlinkedUnit.libraryNameLength = libraryElement.nameLength;
+        unlinkedUnit.libraryDocumentationComment =
+            serializeDocumentation(libraryElement);
       }
-      b.publicNamespace = new UnlinkedPublicNamespaceBuilder(
+      unlinkedUnit.publicNamespace = new UnlinkedPublicNamespaceBuilder(
           exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
               .map((CompilationUnitElement e) => e.uri)
               .toList(),
           names: names);
-      b.exports = libraryElement.exports.map(serializeExportNonPublic).toList();
-      b.imports = libraryElement.imports.map(serializeImport).toList();
-      b.parts = libraryElement.parts
+      unlinkedUnit.exports =
+          libraryElement.exports.map(serializeExportNonPublic).toList();
+      unlinkedUnit.imports =
+          libraryElement.imports.map(serializeImport).toList();
+      unlinkedUnit.parts = libraryElement.parts
           .map((CompilationUnitElement e) =>
               new UnlinkedPartBuilder(uriOffset: e.uriOffset, uriEnd: e.uriEnd))
           .toList();
     } else {
       // TODO(paulberry): we need to figure out a way to record library, part,
       // import, and export declarations that appear in non-defining
       // compilation units (even though such declarations are prohibited by the
       // language), so that if the user makes code changes that cause a
       // non-defining compilation unit to become a defining compilation unit,
       // we can create a correct summary by simply re-linking.
-      b.publicNamespace = new UnlinkedPublicNamespaceBuilder(names: names);
+      unlinkedUnit.publicNamespace =
+          new UnlinkedPublicNamespaceBuilder(names: names);
     }
-    b.classes = element.types.map(serializeClass).toList();
-    b.enums = element.enums.map(serializeEnum).toList();
-    b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
+    unlinkedUnit.classes = compilationUnit.types.map(serializeClass).toList();
+    unlinkedUnit.enums = compilationUnit.enums.map(serializeEnum).toList();
+    unlinkedUnit.typedefs =
+        compilationUnit.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
-        element.functions.map(serializeExecutable).toList();
-    for (PropertyAccessorElement accessor in element.accessors) {
+        compilationUnit.functions.map(serializeExecutable).toList();
+    for (PropertyAccessorElement accessor in compilationUnit.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
     }
-    b.executables = executables;
+    unlinkedUnit.executables = executables;
     List<UnlinkedVariableBuilder> variables = <UnlinkedVariableBuilder>[];
-    for (PropertyAccessorElement accessor in element.accessors) {
+    for (PropertyAccessorElement accessor in compilationUnit.accessors) {
       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;
-    unlinkedUnits.add(b);
-    linkedUnits.add(new LinkedUnitBuilder(references: linkedReferences));
-    unitUris.add(element.source.uri.toString());
-    unlinkedReferences = null;
-    linkedReferences = null;
+    unlinkedUnit.variables = variables;
+    unlinkedUnit.references = unlinkedReferences;
+    linkedUnit.references = linkedReferences;
+    unitUri = compilationUnit.source.uri.toString();
   }
 
   /**
-   * Add [exportedLibrary] (and the transitive closure of all libraries it
-   * exports) to the dependency table ([LinkedLibrary.dependencies]).
-   */
-  void addTransitiveExportClosure(LibraryElement exportedLibrary) {
-    if (librariesAddedToTransitiveExportClosure.add(exportedLibrary)) {
-      serializeDependency(exportedLibrary);
-      for (LibraryElement transitiveExport
-          in exportedLibrary.exportedLibraries) {
-        addTransitiveExportClosure(transitiveExport);
-      }
-    }
-  }
-
-  /**
-   * Fill in [prefixMap] using information from [libraryElement.imports].
-   */
-  void computePrefixMap() {
-    for (ImportElement import in libraryElement.imports) {
-      if (import.prefix == null) {
-        continue;
-      }
-      import.importedLibrary.exportNamespace.definedNames
-          .forEach((String name, Element e) {
-        if (new NameFilter.forNamespaceCombinators(import.combinators)
-            .accepts(name)) {
-          prefixMap[e] = import.prefix;
-        }
-      });
-    }
-  }
-
-  /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
   int findTypeParameterIndex(TypeParameterType type, Element context) {
     int index = 0;
     while (context != null) {
       List<TypeParameterElement> typeParameters;
       if (context is ClassElement) {
         typeParameters = context.typeParameters;
       } else if (context is FunctionTypeAliasElement) {
@@ skipping 80 matching lines @@
   /**
    * Serialize the given [expression], creating an [UnlinkedConstBuilder].
    */
   UnlinkedConstBuilder serializeConstExpr(Expression expression) {
     _ConstExprSerializer serializer = new _ConstExprSerializer(this);
     serializer.serialize(expression);
     return serializer.toBuilder();
   }
 
   /**
-   * Return the index of the entry in the dependency table
-   * ([LinkedLibrary.dependencies]) for the given [dependentLibrary].  A new
-   * entry is added to the table if necessary to satisfy the request.
-   */
-  int serializeDependency(LibraryElement dependentLibrary) {
-    return dependencyMap.putIfAbsent(dependentLibrary, () {
-      int index = dependencies.length;
-      List<String> parts = dependentLibrary.parts
-          .map((CompilationUnitElement e) => e.source.uri.toString())
-          .toList();
-      dependencies.add(new LinkedDependencyBuilder(
-          uri: dependentLibrary.source.uri.toString(), parts: parts));
-      return index;
-    });
-  }
-
-  /**
    * Serialize documentation from the given [element], creating an
    * [UnlinkedDocumentationComment].
    *
    * If [element] has no documentation, `null` is returned.
    */
   UnlinkedDocumentationCommentBuilder serializeDocumentation(Element element) {
     if (element.documentationComment == null) {
       return null;
     }
     return new UnlinkedDocumentationCommentBuilder(
@@ skipping 79 matching lines @@
     b.uriOffset = exportElement.uriOffset;
     b.uriEnd = exportElement.uriEnd;
     return b;
   }
 
   /**
    * Serialize the given [exportElement] into an [UnlinkedExportPublic].
    */
   UnlinkedExportPublicBuilder serializeExportPublic(
       ExportElement exportElement) {
-    addTransitiveExportClosure(exportElement.exportedLibrary);
     UnlinkedExportPublicBuilder b = new UnlinkedExportPublicBuilder();
     b.uri = exportElement.uri;
     b.combinators = exportElement.combinators.map(serializeCombinator).toList();
     return b;
   }
 
   /**
    * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
    * Also, add linked information about it to the [linkedImports] list.
    */
   UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder();
     b.isDeferred = importElement.isDeferred;
     b.offset = importElement.nameOffset;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
       b.prefixReference = serializePrefix(importElement.prefix);
       b.prefixOffset = importElement.prefix.nameOffset;
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       b.uri = importElement.uri;
       b.uriOffset = importElement.uriOffset;
       b.uriEnd = importElement.uriEnd;
     }
-    addTransitiveExportClosure(importElement.importedLibrary);
-    linkedImports.add(serializeDependency(importElement.importedLibrary));
     return b;
   }
 
   /**
-   * Serialize the whole library element into a [LinkedLibrary].  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].
-   */
-  LinkedLibraryBuilder serializeLibrary() {
-    computePrefixMap();
-    LinkedLibraryBuilder pb = new LinkedLibraryBuilder();
-    addCompilationUnitElements(libraryElement.definingCompilationUnit, 0);
-    for (int i = 0; i < libraryElement.parts.length; i++) {
-      addCompilationUnitElements(libraryElement.parts[i], i + 1);
-    }
-    pb.units = linkedUnits;
-    pb.dependencies = dependencies;
-    pb.importDependencies = linkedImports;
-    List<String> exportedNames =
-        libraryElement.exportNamespace.definedNames.keys.toList();
-    exportedNames.sort();
-    List<LinkedExportNameBuilder> exportNames = <LinkedExportNameBuilder>[];
-    for (String name in exportedNames) {
-      if (libraryElement.publicNamespace.definedNames.containsKey(name)) {
-        continue;
-      }
-      Element element = libraryElement.exportNamespace.get(name);
-      LibraryElement dependentLibrary = element.library;
-      CompilationUnitElement unitElement =
-          element.getAncestor((Element e) => e is CompilationUnitElement);
-      int unit = dependentLibrary.units.indexOf(unitElement);
-      assert(unit != -1);
-      ReferenceKind kind = _getReferenceKind(element);
-      exportNames.add(new LinkedExportNameBuilder(
-          name: name,
-          dependency: serializeDependency(dependentLibrary),
-          unit: unit,
-          kind: kind));
-    }
-    pb.exportNames = exportNames;
-    return pb;
-  }
-
-  /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParam(ParameterElement parameter,
       [Element context]) {
     context ??= parameter;
     UnlinkedParamBuilder b = new UnlinkedParamBuilder();
     b.name = parameter.name;
     b.nameOffset = parameter.nameOffset;
     switch (parameter.parameterKind) {
       case ParameterKind.REQUIRED:
@@ skipping 178 matching lines @@
       int numTypeParameters = 0;
       if (element is TypeParameterizedElement) {
         numTypeParameters = element.typeParameters.length;
       }
       // Figure out a prefix that may be used to refer to the given type.
       // TODO(paulberry): to avoid subtle relinking inconsistencies we
       // should use the actual prefix from the AST (a given type may be
       // reachable via multiple prefixes), but sadly, this information is
       // not recorded in the element model.
       int prefixReference = 0;
-      PrefixElement prefix = prefixMap[element];
+      PrefixElement prefix = librarySerializer.prefixMap[element];
       if (prefix != null) {
         prefixReference = serializePrefix(prefix);
       }
       int index = unlinkedReferences.length;
       unlinkedReferences.add(new UnlinkedReferenceBuilder(
           name: element.name, prefixReference: prefixReference));
       linkedReferences.add(new LinkedReferenceBuilder(
-          dependency: serializeDependency(dependentLibrary),
+          dependency: librarySerializer.serializeDependency(dependentLibrary),
           kind: _getReferenceKind(element),
           unit: unit,
           numTypeParameters: numTypeParameters));
       return index;
     });
   }
-
-  ReferenceKind _getReferenceKind(Element element) {
-    ReferenceKind kind;
-    if (element is PropertyAccessorElement) {
-      kind = ReferenceKind.topLevelPropertyAccessor;
-    } else if (element is FunctionTypeAliasElement) {
-      kind = ReferenceKind.typedef;
-    } else if (element is ClassElement) {
-      kind = ReferenceKind.classOrEnum;
-    } else if (element is FunctionElement) {
-      kind = ReferenceKind.topLevelFunction;
-    } else {
-      throw new Exception('Unexpected element kind: ${element.runtimeType}');
-    }
-    return kind;
-  }
 }
+
+/**
+ * Instances of this class keep track of intermediate state during
+ * serialization of a single constant [Expression].
+ */
+class _ConstExprSerializer extends AbstractConstExprSerializer {
+  final _CompilationUnitSerializer serializer;
+
+  _ConstExprSerializer(this.serializer);
+
+  TypeRefBuilder serializeIdentifier(Identifier identifier) {
+    Element element = identifier.staticElement;
+    assert(element != null);
+    // TODO(scheglov) how to serialize element references?
+    return new TypeRefBuilder(
+        reference: serializer._getElementReferenceId(element));
+  }
+
+  @override
+  TypeRefBuilder serializeType(TypeName typeName) {
+    DartType type = typeName != null ? typeName.type : DynamicTypeImpl.instance;
+    return serializer.serializeTypeRef(type, null);
+  }
+}
+
+/**
+ * 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;
+
+  /**
+   * 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 [LinkedLibrary.dependencies].
+   */
+  final List<LinkedDependencyBuilder> dependencies =
+      <LinkedDependencyBuilder>[];
+
+  /**
+   * The linked portion of the "imports table".  This is the list of ints
+   * which should be written to [LinkedLibrary.imports].
+   */
+  final List<int> linkedImports = <int>[];
+
+  /**
+   * Set of libraries which have been seen so far while visiting the transitive
+   * closure of exports.
+   */
+  final Set<LibraryElement> librariesAddedToTransitiveExportClosure =
+      new Set<LibraryElement>();
+
+  /**
+   * Map from imported element to the prefix which may be used to refer to that
+   * element; elements for which no prefix is needed are absent from this map.
+   */
+  final Map<Element, PrefixElement> prefixMap = <Element, PrefixElement>{};
+
+  /**
+   * List of serializers for the compilation units constituting this library.
+   */
+  final List<_CompilationUnitSerializer> compilationUnitSerializers =
+      <_CompilationUnitSerializer>[];
+
+  _LibrarySerializer(this.libraryElement, this.typeProvider) {
+    dependencies.add(new LinkedDependencyBuilder());
+    dependencyMap[libraryElement] = 0;
+  }
+
+  /**
+   * Retrieve a list of the URIs for the compilation units in the library.
+   */
+  List<String> get unitUris => compilationUnitSerializers
+      .map((_CompilationUnitSerializer s) => s.unitUri)
+      .toList();
+
+  /**
+   * Retrieve a list of the [UnlinkedUnitBuilder]s for the compilation units in
+   * the library.
+   */
+  List<UnlinkedUnitBuilder> get unlinkedUnits => compilationUnitSerializers
+      .map((_CompilationUnitSerializer s) => s.unlinkedUnit)
+      .toList();
+
+  /**
+   * Add [exportedLibrary] (and the transitive closure of all libraries it
+   * exports) to the dependency table ([LinkedLibrary.dependencies]).
+   */
+  void addTransitiveExportClosure(LibraryElement exportedLibrary) {
+    if (librariesAddedToTransitiveExportClosure.add(exportedLibrary)) {
+      serializeDependency(exportedLibrary);
+      for (LibraryElement transitiveExport
+          in exportedLibrary.exportedLibraries) {
+        addTransitiveExportClosure(transitiveExport);
+      }
+    }
+  }
+
+  /**
+   * Fill in [prefixMap] using information from [libraryElement.imports].
+   */
+  void computePrefixMap() {
+    for (ImportElement import in libraryElement.imports) {
+      if (import.prefix == null) {
+        continue;
+      }
+      import.importedLibrary.exportNamespace.definedNames
+          .forEach((String name, Element e) {
+        if (new NameFilter.forNamespaceCombinators(import.combinators)
+            .accepts(name)) {
+          prefixMap[e] = import.prefix;
+        }
+      });
+    }
+  }
+
+  /**
+   * Return the index of the entry in the dependency table
+   * ([LinkedLibrary.dependencies]) for the given [dependentLibrary].  A new
+   * entry is added to the table if necessary to satisfy the request.
+   */
+  int serializeDependency(LibraryElement dependentLibrary) {
+    return dependencyMap.putIfAbsent(dependentLibrary, () {
+      int index = dependencies.length;
+      List<String> parts = dependentLibrary.parts
+          .map((CompilationUnitElement e) => e.source.uri.toString())
+          .toList();
+      dependencies.add(new LinkedDependencyBuilder(
+          uri: dependentLibrary.source.uri.toString(), parts: parts));
+      return index;
+    });
+  }
+
+  /**
+   * Serialize the whole library element into a [LinkedLibrary].  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].
+   */
+  LinkedLibraryBuilder serializeLibrary() {
+    computePrefixMap();
+    LinkedLibraryBuilder pb = new LinkedLibraryBuilder();
+    for (ExportElement exportElement in libraryElement.exports) {
+      addTransitiveExportClosure(exportElement.exportedLibrary);
+    }
+    for (ImportElement importElement in libraryElement.imports) {
+      addTransitiveExportClosure(importElement.importedLibrary);
+      linkedImports.add(serializeDependency(importElement.importedLibrary));
+    }
+    compilationUnitSerializers.add(new _CompilationUnitSerializer(
+        this, libraryElement.definingCompilationUnit, 0));
+    for (int i = 0; i < libraryElement.parts.length; i++) {
+      compilationUnitSerializers.add(
+          new _CompilationUnitSerializer(this, libraryElement.parts[i], i + 1));
+    }
+    for (_CompilationUnitSerializer compilationUnitSerializer
+        in compilationUnitSerializers) {
+      compilationUnitSerializer.addCompilationUnitElements();
+    }
+    pb.units = compilationUnitSerializers
+        .map((_CompilationUnitSerializer s) => s.linkedUnit)
+        .toList();
+    pb.dependencies = dependencies;
+    pb.importDependencies = linkedImports;
+    List<String> exportedNames =
+        libraryElement.exportNamespace.definedNames.keys.toList();
+    exportedNames.sort();
+    List<LinkedExportNameBuilder> exportNames = <LinkedExportNameBuilder>[];
+    for (String name in exportedNames) {
+      if (libraryElement.publicNamespace.definedNames.containsKey(name)) {
+        continue;
+      }
+      Element element = libraryElement.exportNamespace.get(name);
+      LibraryElement dependentLibrary = element.library;
+      CompilationUnitElement unitElement =
+          element.getAncestor((Element e) => e is CompilationUnitElement);
+      int unit = dependentLibrary.units.indexOf(unitElement);
+      assert(unit != -1);
+      ReferenceKind kind = _getReferenceKind(element);
+      exportNames.add(new LinkedExportNameBuilder(
+          name: name,
+          dependency: serializeDependency(dependentLibrary),
+          unit: unit,
+          kind: kind));
+    }
+    pb.exportNames = exportNames;
+    return pb;
+  }
+}