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

pkg/analyzer/test/src/summary/index_unit_test.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ skipping 607 matching lines @@
 
   /**
    * Asserts that [unitIndex] has an item with the expected properties.
    */
   void _assertHasRelation(
       Element element,
       IndexRelationKind expectedRelationKind,
       ExpectedLocation expectedLocation) {
     int elementId = _findElementId(element);
     int matchIndex;
-    for (int i = 0; i < unitIndex.locationOffsets.length; i++) {
-      if (unitIndex.elements[i] == elementId &&
-          unitIndex.locationOffsets[i] == expectedLocation.offset &&
-          unitIndex.locationLengths[i] == expectedLocation.length) {
+    for (int i = 0; i < unitIndex.usedElementOffsets.length; i++) {
+      if (unitIndex.usedElements[i] == elementId &&
+          unitIndex.usedElementOffsets[i] == expectedLocation.offset &&
+          unitIndex.usedElementLengths[i] == expectedLocation.length) {
         if (matchIndex == null) {
           matchIndex = i;
         } else {
           _failWithIndexDump('more then one ($matchIndex and $i) match found\n'
               '$element at $expectedLocation');
         }
       }
     }
     if (matchIndex != null &&
-        unitIndex.kinds[matchIndex] == expectedRelationKind) {
+        unitIndex.usedElementKinds[matchIndex] == expectedRelationKind) {
       return;
     }
     _failWithIndexDump(
         'not found\n$element $expectedRelationKind at $expectedLocation');
   }
 
   ExpectedLocation _expectedLocation(String search,
       {int length, bool isQualified: false, bool isResolved: true}) {
     int offset = findOffset(search);
     if (length == null) {
       length = getLeadingIdentifierLength(search);
     }
     return new ExpectedLocation(
         testUnitElement, offset, length, isQualified, isResolved);
   }
 
   void _failWithIndexDump(String msg) {
     String packageIndexJsonString =
         new JsonEncoder.withIndent('  ').convert(packageIndex.toJson());
     fail('$msg in\n' + packageIndexJsonString);
   }
 
   /**
    * Return the [element] identifier in [packageIndex] or fail.
    */
   int _findElementId(Element element) {
-    int elementUnitId = _getElementUnitId(element);
+    int unitId = _getUnitId(element);
     int offset = element.nameOffset;
     if (element is LibraryElement || element is CompilationUnitElement) {
       offset = 0;
     }
     IndexSyntheticElementKind kind =
         PackageIndexAssembler.getIndexElementKind(element);
     for (int elementId = 0;
         elementId < packageIndex.elementUnits.length;
         elementId++) {
-      if (packageIndex.elementUnits[elementId] == elementUnitId &&
+      if (packageIndex.elementUnits[elementId] == unitId &&
           packageIndex.elementOffsets[elementId] == offset &&
           packageIndex.elementKinds[elementId] == kind) {
         return elementId;
       }
     }
     _failWithIndexDump('Element $element is not referenced');
     return 0;
   }
 
-  int _getElementUnitId(Element element) {
+  int _getStringId(String str) {
+    int id = packageIndex.strings.indexOf(str);
+    expect(id, isNonNegative);
+    return id;
+  }
+
+  int _getUnitId(Element element) {
     CompilationUnitElement unitElement =
         PackageIndexAssembler.getUnitElement(element);
     int libraryUriId = _getUriId(unitElement.library.source.uri);
     int unitUriId = _getUriId(unitElement.source.uri);
-    for (int i = 0; i < packageIndex.elementLibraryUris.length; i++) {
-      if (packageIndex.elementLibraryUris[i] == libraryUriId &&
-          packageIndex.elementUnitUris[i] == unitUriId) {
+    expect(packageIndex.unitLibraryUris,
+        hasLength(packageIndex.unitUnitUris.length));
+    for (int i = 0; i < packageIndex.unitLibraryUris.length; i++) {
+      if (packageIndex.unitLibraryUris[i] == libraryUriId &&
+          packageIndex.unitUnitUris[i] == unitUriId) {
         return i;
       }
     }
     _failWithIndexDump('Unit $unitElement of $element is not referenced');
     return -1;
   }
 
-  int _getStringId(String str) {
-    int id = packageIndex.strings.indexOf(str);
-    expect(id, isNonNegative);
-    return id;
-  }
-
   int _getUriId(Uri uri) {
     String str = uri.toString();
     return _getStringId(str);
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     PackageIndexAssembler assembler = new PackageIndexAssembler();
     assembler.index(testUnit);
     // assemble, write and read
     PackageIndexBuilder indexBuilder = assembler.assemble();
     List<int> indexBytes = indexBuilder.toBuffer();
     packageIndex = new PackageIndex.fromBuffer(indexBytes);
     // prepare the only unit index
     expect(packageIndex.units, hasLength(1));
     unitIndex = packageIndex.units[0];
+    expect(unitIndex.unit, _getUnitId(testUnitElement));
   }
 }
 
 class _ElementIndexAssert {
   final PackageIndexAssemblerTest test;
   final Element element;
 
   _ElementIndexAssert(this.test, this.element);
 
   void isExtendedAt(String search, {int length}) {
@@ skipping 26 matching lines @@
         test._expectedLocation(search, length: length));
   }
 
   void isReferencedQualifiedAt(String search, {int length}) {
     test._assertHasRelation(
         element,
         IndexRelationKind.IS_REFERENCED_QUALIFIED_BY,
         test._expectedLocation(search, length: length));
   }
 }