Sort strings in the index.

pkg/analyzer/lib/src/summary/index_unit.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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/member.dart';
@@ skipping 15 matching lines @@
 
   /**
    * Map associating [CompilationUnitElement]s with their identifiers, which
    * are indices into [_unitLibraryUris] and [_unitUnitUris].
    */
   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].
+   * [CompilationUnitElement].
    */
-  final List<int> _unitLibraryUris = <int>[];
+  final List<_StringInfo> _unitLibraryUris = <_StringInfo>[];
 
   /**
    * Each item of this list corresponds to the unit URI of a unique
-   * [CompilationUnitElement].  It is an index into [_strings].
+   * [CompilationUnitElement].
    */
-  final List<int> _unitUnitUris = <int>[];
+  final List<_StringInfo> _unitUnitUris = <_StringInfo>[];
 
   /**
-   * Map associating strings with their identifiers, which are indices
-   * into [_strings].
+   * Map associating strings with their [_StringInfo]s.
    */
-  final Map<String, int> _stringMap = <String, int>{};
-
-  /**
-   * List of unique strings used in this index.
-   */
-  final List<String> _strings = <String>[];
+  final Map<String, _StringInfo> _stringMap = <String, _StringInfo>{};
 
   /**
    * List of information about each unit indexed in this index.
    */
   final List<_UnitIndexAssembler> _units = <_UnitIndexAssembler>[];
 
   /**
    * Assemble a new [PackageIndexBuilder] using the information gathered by
    * [index].
    */
   PackageIndexBuilder assemble() {
+    // sort strings end set IDs
+    List<_StringInfo> stringInfoList = _stringMap.values.toList();
+    stringInfoList.sort((a, b) {
+      return a.value.compareTo(b.value);
+    });
+    for (int i = 0; i < stringInfoList.length; i++) {
+      stringInfoList[i].id = i;
+    }
+    // sort elements and set IDs
     List<_ElementInfo> elementInfoList = _elementMap.values.toList();
     elementInfoList.sort((a, b) {
       return a.offset - b.offset;
     });
     for (int i = 0; i < elementInfoList.length; i++) {
       elementInfoList[i].id = i;
     }
     return new PackageIndexBuilder(
-        unitLibraryUris: _unitLibraryUris,
-        unitUnitUris: _unitUnitUris,
+        unitLibraryUris: _unitLibraryUris.map((s) => s.id).toList(),
+        unitUnitUris: _unitUnitUris.map((s) => s.id).toList(),
         elementUnits: elementInfoList.map((e) => e.unitId).toList(),
         elementOffsets: elementInfoList.map((e) => e.offset).toList(),
         elementKinds: elementInfoList.map((e) => e.kind).toList(),
-        strings: _strings,
+        strings: stringInfoList.map((s) => s.value).toList(),
         units: _units.map((unit) => unit.assemble()).toList());
   }
 
   /**
    * Index the given fully resolved [unit].
    */
   void index(CompilationUnit unit) {
     int unitId = _getUnitId(unit.element);
     _UnitIndexAssembler assembler = new _UnitIndexAssembler(this, unitId);
     _units.add(assembler);
@@ skipping 14 matching lines @@
       int offset = element.nameOffset;
       if (element is LibraryElement || element is CompilationUnitElement) {
         offset = 0;
       }
       IndexSyntheticElementKind kind = getIndexElementKind(element);
       return new _ElementInfo(unitId, offset, kind);
     });
   }
 
   /**
-   * Add information about [str] to [_strings] if necessary, and return the
-   * location in this array representing [str].
+   * Return the unique [_StringInfo] corresponding the [str].  The field
+   * [_StringInfo.id] is filled by [assemble] during final sorting.
    */
-  int _getStringId(String str) {
+  _StringInfo _getStringInfo(String str) {
     return _stringMap.putIfAbsent(str, () {
-      int id = _strings.length;
-      _strings.add(str);
-      return id;
+      return new _StringInfo(str);
     });
   }
 
   /**
    * Add information about [unitElement] to [_unitUnitUris] and
    * [_unitLibraryUris] if necessary, and return the location in those
    * arrays representing [unitElement].
    */
   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));
+      _unitLibraryUris.add(_getUriInfo(unitElement.library.source.uri));
+      _unitUnitUris.add(_getUriInfo(unitElement.source.uri));
       return id;
     });
   }
 
   /**
-   * Return the identifier corresponding to [uri].
+   * Return the unique [_StringInfo] corresponding [uri].  The field
+   * [_StringInfo.id] is filled by [assemble] during final sorting.
    */
-  int _getUriId(Uri uri) {
+  _StringInfo _getUriInfo(Uri uri) {
     String str = uri.toString();
-    return _getStringId(str);
+    return _getStringInfo(str);
   }
 
   /**
    * Return the kind of the given [element].
    */
   static IndexSyntheticElementKind getIndexElementKind(Element element) {
     if (element.isSynthetic) {
       if (element is ConstructorElement) {
         return IndexSyntheticElementKind.constructor;
       }
@@ skipping 23 matching lines @@
   }
 }
 
 /**
  * Information about a single defined name.  Any [_DefinedNameInfo] is always
  * part of a [_UnitIndexAssembler], so [offset] should be understood within the
  * context of the compilation unit pointed to by the [_UnitIndexAssembler].
  */
 class _DefinedNameInfo {
   /**
-   * The identifier of the name returned [PackageIndexAssembler._getStringId].
+   * The information about the name returned from
+   * [PackageIndexAssembler._getStringInfo].
    */
-  final int nameId;
+  final _StringInfo nameInfo;
 
   /**
    * The coarse-grained kind of the defined name.
    */
   final IndexNameKind kind;
 
   /**
    * The name offset of the defined element.
    */
   final int offset;
 
-  _DefinedNameInfo(this.nameId, this.kind, this.offset);
+  _DefinedNameInfo(this.nameInfo, this.kind, this.offset);
 }
 
 /**
  * Information about an element referenced in index.
  */
 class _ElementInfo {
   /**
    * The identifier of the [CompilationUnitElement] containing this element.
    */
   final int unitId;
@@ skipping 11 matching lines @@
   /**
    * The unique id of the element.  It is set after indexing of the whole
    * package is done and we are assembling the full package index.
    */
   int id;
 
   _ElementInfo(this.unitId, this.offset, this.kind);
 }
 
 /**
+ * Information about a string referenced in the index.
+ */
+class _StringInfo {
+  /**
+   * The value of the string.
+   */
+  final String value;
+
+  /**
+   * The unique id of the string.  It is set after indexing of the whole
+   * package is done and we are assembling the full package index.
+   */
+  int id;
+
+  _StringInfo(this.value);
+}
+
+/**
  * Information about a single relation.  Any [_ElementRelationInfo] is always
  * part of a [_UnitIndexAssembler], so [offset] and [length] should be
  * understood within the context of the compilation unit pointed to by the
  * [_UnitIndexAssembler].
  */
 class _ElementRelationInfo {
   final _ElementInfo elementInfo;
   final IndexRelationKind kind;
   final int offset;
   final int length;
@@ skipping 396 matching lines @@
   }
 }
 
 /**
  * Information about a single name relation.  Any [_NameRelationInfo] is always
  * part of a [_UnitIndexAssembler], so [offset] should be understood within the
  * context of the compilation unit pointed to by the [_UnitIndexAssembler].
  */
 class _NameRelationInfo {
   /**
-   * The identifier of the name returned [PackageIndexAssembler._getStringId].
+   * The information about the name returned from
+   * [PackageIndexAssembler._getStringInfo].
    */
-  final int nameId;
+  final _StringInfo nameInfo;
   final IndexRelationKind kind;
   final int offset;
 
-  _NameRelationInfo(this.nameId, this.kind, this.offset);
+  _NameRelationInfo(this.nameInfo, this.kind, this.offset);
 }
 
 /**
  * Assembler of a single [CompilationUnit] index.  The intended usage sequence:
  *
  *  - Call [defineName] for each name defined in the compilation unit.
  *  - Call [addElementRelation] for each element relation found in the
  *    compilation unit.
  *  - Call [addNameRelation] for each name relation found in the
  *    compilation unit.
@@ skipping 13 matching lines @@
   void addElementRelation(Element element, IndexRelationKind kind, int offset,
       int length, bool isQualified) {
     try {
       _ElementInfo elementInfo = pkg._getElementInfo(element);
       elementRelations.add(new _ElementRelationInfo(
           elementInfo, kind, offset, length, isQualified));
     } on StateError {}
   }
 
   void addNameRelation(String name, IndexRelationKind kind, int offset) {
-    int nameId = pkg._getStringId(name);
+    _StringInfo nameId = pkg._getStringInfo(name);
     nameRelations.add(new _NameRelationInfo(nameId, kind, offset));
   }
 
   /**
    * Assemble a new [UnitIndexBuilder] using the information gathered
    * by [addElementRelation] and [defineName].
    */
   UnitIndexBuilder assemble() {
     definedNames.sort((a, b) {
-      return a.nameId - b.nameId;
+      return a.nameInfo.id - b.nameInfo.id;
     });
     elementRelations.sort((a, b) {
       return a.elementInfo.id - b.elementInfo.id;
     });
     nameRelations.sort((a, b) {
-      return a.nameId - b.nameId;
+      return a.nameInfo.id - b.nameInfo.id;
     });
     return new UnitIndexBuilder(
         unit: unitId,
-        definedNames: definedNames.map((n) => n.nameId).toList(),
+        definedNames: definedNames.map((n) => n.nameInfo.id).toList(),
         definedNameKinds: definedNames.map((n) => n.kind).toList(),
         definedNameOffsets: definedNames.map((n) => n.offset).toList(),
         usedElements: elementRelations.map((r) => r.elementInfo.id).toList(),
         usedElementKinds: elementRelations.map((r) => r.kind).toList(),
         usedElementOffsets: elementRelations.map((r) => r.offset).toList(),
         usedElementLengths: elementRelations.map((r) => r.length).toList(),
         usedElementIsQualifiedFlags:
             elementRelations.map((r) => r.isQualified).toList(),
-        usedNames: nameRelations.map((r) => r.nameId).toList(),
+        usedNames: nameRelations.map((r) => r.nameInfo.id).toList(),
         usedNameKinds: nameRelations.map((r) => r.kind).toList(),
         usedNameOffsets: nameRelations.map((r) => r.offset).toList());
   }
 
   void defineName(String name, IndexNameKind kind, int offset) {
-    int nameId = pkg._getStringId(name);
-    definedNames.add(new _DefinedNameInfo(nameId, kind, offset));
+    _StringInfo nameInfo = pkg._getStringInfo(name);
+    definedNames.add(new _DefinedNameInfo(nameInfo, kind, offset));
   }
 }