Merge the prefix and references tables.

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 43 matching lines @@
   final List<PrelinkedDependencyBuilder> dependencies =
       <PrelinkedDependencyBuilder>[];
 
   /**
    * The prelinked portion of the "imports table".  This is the list of ints
    * which should be written to [PrelinkedLibrary.imports].
    */
   final List<int> prelinkedImports = <int>[];
 
   /**
-   * Map from prefix [String] to the index of the entry in the "prefix" table
-   * that refers to it.  The empty prefix is not included in this map.
-   */
-  final Map<String, int> prefixMap = <String, int>{};
-
-  /**
-   * The "prefix table".  This is the list of objects which should be written
-   * to [UnlinkedLibrary.prefixes].
-   */
-  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 [UnlinkedUnit.references].
    */
   List<UnlinkedReferenceBuilder> unlinkedReferences;
@@ skipping 21 matching lines @@
       new Set<LibraryElement>();
 
   /**
    * [BuilderContext] used to serialize the output summary.
    */
   final BuilderContext ctx;
 
   _LibrarySerializer(this.ctx, this.libraryElement, this.typeProvider) {
     dependencies.add(encodePrelinkedDependency(ctx));
     dependencyMap[libraryElement] = 0;
-    prefixes.add(encodeUnlinkedPrefix(ctx));
   }
 
   /**
    * Retrieve the library element for `dart:core`.
    */
   LibraryElement get coreLibrary => typeProvider.objectType.element.library;
 
   /**
    * Add all classes, enums, typedefs, executables, and top level variables
    * from the given compilation unit [element] to the library summary.
    * [unitNum] indicates the ordinal position of this compilation unit in the
    * library.
    */
   void addCompilationUnitElements(CompilationUnitElement element, int unitNum) {
     UnlinkedUnitBuilder b = new UnlinkedUnitBuilder(ctx);
+    unlinkedReferences = <UnlinkedReferenceBuilder>[
+      encodeUnlinkedReference(ctx)
+    ];
+    prelinkedReferences = <PrelinkedReferenceBuilder>[
+      encodePrelinkedReference(ctx, kind: PrelinkedReferenceKind.classOrEnum)
+    ];
     if (unitNum == 0) {
       // 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.
       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>[
-      encodeUnlinkedReference(ctx)
-    ];
-    prelinkedReferences = <PrelinkedReferenceBuilder>[
-      encodePrelinkedReference(ctx, kind: PrelinkedReferenceKind.classOrEnum)
-    ];
     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));
       }
     }
@@ skipping 209 matching lines @@
   /**
    * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
    * Also, add pre-linked information about it to the [prelinkedImports] list.
    */
   UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder(ctx);
     b.isDeferred = importElement.isDeferred;
     b.offset = importElement.nameOffset;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
-      b.prefix = prefixMap.putIfAbsent(importElement.prefix.name, () {
-        int index = prefixes.length;
-        prefixes
-            .add(encodeUnlinkedPrefix(ctx, name: importElement.prefix.name));
-        return index;
-      });
+      b.prefixReference = serializePrefix(importElement.prefix);
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       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].
    */
   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;
     pb.units = units;
-    pb.unlinked = ub;
     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 18 matching lines @@
       }
       b.parameters = type.parameters.map(serializeParam).toList();
     } else {
       b.type = serializeTypeRef(type, parameter);
       b.hasImplicitType = parameter.hasImplicitType;
     }
     return b;
   }
 
   /**
+   * Serialize the given [prefix] into an index into the references table.
+   */
+  int serializePrefix(PrefixElement element) {
+    return referenceMap.putIfAbsent(element, () {
+      assert(unlinkedReferences.length == prelinkedReferences.length);
+      int index = unlinkedReferences.length;
+      unlinkedReferences.add(encodeUnlinkedReference(ctx, name: element.name));
+      prelinkedReferences.add(
+          encodePrelinkedReference(ctx, kind: PrelinkedReferenceKind.prefix));
+      return index;
+    });
+  }
+
+  /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder(ctx);
     b.name = typedefElement.name;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
       b.returnType =
@@ skipping 96 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;
   }
 }