Rename some index fields and use single 'UnitIndex.unit' field.

pkg/analyzer/lib/src/summary/index_unit.dart

Index: pkg/analyzer/lib/src/summary/index_unit.dart
diff --git a/pkg/analyzer/lib/src/summary/index_unit.dart b/pkg/analyzer/lib/src/summary/index_unit.dart
index c2c298e513ce0a40ce20dca4b8a390eb420ef460..51192dbfa388c5373e57d3a76d100333a531c4d5 100644
--- a/pkg/analyzer/lib/src/summary/index_unit.dart
+++ b/pkg/analyzer/lib/src/summary/index_unit.dart
@@ -24,22 +24,22 @@ class PackageIndexAssembler {
 
   /**
    * Map associating [CompilationUnitElement]s with their identifiers, which
-   * are indices into [_elementLibraryUris] and [_elementUnitUris].
+   * are indices into [_unitLibraryUris] and [_unitUnitUris].
    */
-  final Map<CompilationUnitElement, int> _elementUnitMap =
+  final Map<CompilationUnitElement, int> _unitMap =
       <CompilationUnitElement, int>{};
 
   /**
    * Each item of this list corresponds to the library URI of a unique
    * [CompilationUnitElement].  It is an index into [_strings].
    */
-  final List<int> _elementLibraryUris = <int>[];
+  final List<int> _unitLibraryUris = <int>[];
 
   /**
    * Each item of this list corresponds to the unit URI of a unique
    * [CompilationUnitElement].  It is an index into [_strings].
    */
-  final List<int> _elementUnitUris = <int>[];
+  final List<int> _unitUnitUris = <int>[];
 
   /**
    * Map associating strings with their identifiers, which are indices
@@ -70,8 +70,8 @@ class PackageIndexAssembler {
       elementInfoList[i].id = i;
     }
     return new PackageIndexBuilder(
-        elementLibraryUris: _elementLibraryUris,
-        elementUnitUris: _elementUnitUris,
+        unitLibraryUris: _unitLibraryUris,
+        unitUnitUris: _unitUnitUris,
         elementUnits: elementInfoList.map((e) => e.unitId).toList(),
         elementOffsets: elementInfoList.map((e) => e.offset).toList(),
         elementKinds: elementInfoList.map((e) => e.kind).toList(),
@@ -96,7 +96,7 @@ class PackageIndexAssembler {
   _ElementInfo _getElementInfo(Element element) {
     return _elementMap.putIfAbsent(element, () {
       CompilationUnitElement unitElement = getUnitElement(element);
-      int unitId = _getUnitElementId(unitElement);
+      int unitId = _getUnitId(unitElement);
       int offset = element.nameOffset;
       if (element is LibraryElement || element is CompilationUnitElement) {
         offset = 0;
@@ -119,16 +119,16 @@ class PackageIndexAssembler {
   }
 
   /**
-   * Add information about [unitElement] to [_elementUnitUris] and
-   * [_elementLibraryUris] if necessary, and return the location in those
+   * Add information about [unitElement] to [_unitUnitUris] and
+   * [_unitLibraryUris] if necessary, and return the location in those
    * arrays representing [unitElement].
    */
-  int _getUnitElementId(CompilationUnitElement unitElement) {
-    return _elementUnitMap.putIfAbsent(unitElement, () {
-      assert(_elementLibraryUris.length == _elementUnitUris.length);
-      int id = _elementUnitUris.length;
-      _elementLibraryUris.add(_getUriId(unitElement.library.source.uri));
-      _elementUnitUris.add(_getUriId(unitElement.source.uri));
+  int _getUnitId(CompilationUnitElement unitElement) {
+    return _unitMap.putIfAbsent(unitElement, () {
+      assert(_unitLibraryUris.length == _unitUnitUris.length);
+      int id = _unitUnitUris.length;
+      _unitLibraryUris.add(_getUriId(unitElement.library.source.uri));
+      _unitUnitUris.add(_getUriId(unitElement.source.uri));
       return id;
     });
   }
@@ -593,15 +593,14 @@ class _UnitIndexAssembler {
       return a.nameId - b.nameId;
     });
     return new UnitIndexBuilder(
+        unit: pkg._getUnitId(unitElement),

[Paul Berry, 2016/02/29 18:39:01]

I don't think this is a bug but I'm nervous about it. 
PackageIndexAssembler.assemble() stores _unitLibraryUris and _unitUnitUris in
the PackageIndexBuilder prior to calling _UnitIndexAssembler.assemble().  Which
means that we might wind up calling pkg._getUnitId() (which could modify those
lists) after they've been stored in PackageIndexBuilder.

Fortunately, the PackageIndexBuilder constructor doesn't make copies of
_unitLibraryUris and _unitUnitUris, so we are ok.  But that's an implementation
detail of PackageIndexBuilder that we shouldn't rely on--if we ever changed it
so that it *did* make copies, this code would break.

I would prefer to have an implementation that doesn't rely on the fact that
PackageIndexBuilder doesn't make copies.

Possible solution: move the call to pkg._getUnitId() into the
_UnitIndexAssembler constructor, and store its return value as a field in
_UnitIndexAssembler rather than storing [unitElement].

[scheglov, 2016/02/29 18:48:27]

Thank you.
I changed it to pass unitId into the UnitIndex constructor.

         definedNames: definedNames.map((n) => n.nameId).toList(),
         definedNameKinds: definedNames.map((n) => n.kind).toList(),
         definedNameOffsets: definedNames.map((n) => n.offset).toList(),
-        elements: relations.map((r) => r.elementInfo.id).toList(),
-        kinds: relations.map((r) => r.kind).toList(),
-        locationOffsets: relations.map((r) => r.offset).toList(),
-        locationLengths: relations.map((r) => r.length).toList(),
-        libraryUri: pkg._getUriId(unitElement.library.source.uri),
-        unitUri: pkg._getUriId(unitElement.source.uri));
+        usedElements: relations.map((r) => r.elementInfo.id).toList(),
+        usedElementKinds: relations.map((r) => r.kind).toList(),
+        usedElementOffsets: relations.map((r) => r.offset).toList(),
+        usedElementLengths: relations.map((r) => r.length).toList());
   }
 
   void defineName(String name, IndexNameKind kind, int offset) {