Improve search for constructors and import elements.

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 23 matching lines @@
         ' isQualified=$isQualified)';
   }
 }
 
 @reflectiveTest
 class PackageIndexAssemblerTest extends AbstractSingleUnitTest {
   PackageIndex packageIndex;
   UnitIndex unitIndex;
 
   _ElementIndexAssert assertThat(Element element) {
-    return new _ElementIndexAssert(this, element);
+    List<_Relation> relations = _getElementRelations(element);
+    return new _ElementIndexAssert(this, element, relations);
   }
 
   _NameIndexAssert assertThatName(String name) {
     return new _NameIndexAssert(this, name);
   }
 
   CompilationUnitElement importedUnit({int index: 0}) {
     List<ImportElement> imports = testLibraryElement.imports;
     return imports[index].importedLibrary.definingCompilationUnit;
   }
@@ skipping 498 matching lines @@
 main() {
   new A(); // 4
   new A.foo(); // 5
 }
 ''');
     ClassElement classA = findElement('A');
     ConstructorElement constA = classA.constructors[0];
     ConstructorElement constA_foo = classA.constructors[1];
     // A()
     assertThat(constA)
+      ..hasRelationCount(2)
       ..isReferencedAt('(); // 1', true, length: 0)
       ..isReferencedAt('(); // 4', true, length: 0);
     // A.foo()
     assertThat(constA_foo)
+      ..hasRelationCount(3)
       ..isReferencedAt('.foo(); // 2', true, length: 4)
       ..isReferencedAt('.foo; // 3', true, length: 4)
       ..isReferencedAt('.foo(); // 5', true, length: 4);
   }
 
   void test_isReferencedBy_ConstructorElement_classTypeAlias() {
     _indexTestUnit('''
 class M {}
 class A implements B {
   A() {}
@@ skipping 272 matching lines @@
       }
     }
     _failWithIndexDump('Not found $name $kind at $offset');
   }
 
   /**
    * Asserts that [unitIndex] has an item with the expected properties.
    */
   void _assertHasRelation(
       Element element,
+      List<_Relation> relations,
       IndexRelationKind expectedRelationKind,
       ExpectedLocation expectedLocation) {
-    int elementId = _findElementId(element);
-    for (int i = 0; i < unitIndex.usedElementOffsets.length; i++) {
-      if (unitIndex.usedElements[i] == elementId &&
-          unitIndex.usedElementKinds[i] == expectedRelationKind &&
-          unitIndex.usedElementOffsets[i] == expectedLocation.offset &&
-          unitIndex.usedElementLengths[i] == expectedLocation.length &&
-          unitIndex.usedElementIsQualifiedFlags[i] ==
-              expectedLocation.isQualified) {
+    for (var relation in relations) {
+      if (relation.kind == expectedRelationKind &&
+          relation.offset == expectedLocation.offset &&
+          relation.length == expectedLocation.length &&
+          relation.isQualified == expectedLocation.isQualified) {
         return;
       }
     }
     _failWithIndexDump(
         'not found\n$element $expectedRelationKind at $expectedLocation');
   }
 
   void _assertUsedName(String name, IndexRelationKind kind,
       ExpectedLocation expectedLocation, bool isNot) {
     int nameId = _getStringId(name);
@@ skipping 40 matching lines @@
       if (packageIndex.elementUnits[elementId] == unitId &&
           packageIndex.elementOffsets[elementId] == info.offset &&
           packageIndex.elementKinds[elementId] == info.kind) {
         return elementId;
       }
     }
     _failWithIndexDump('Element $element is not referenced');
     return 0;
   }
 
+  /**
+   * Return all relations with [element] in [unitIndex].
+   */
+  List<_Relation> _getElementRelations(Element element) {
+    int elementId = _findElementId(element);
+    List<_Relation> relations = <_Relation>[];
+    for (int i = 0; i < unitIndex.usedElementOffsets.length; i++) {
+      if (unitIndex.usedElements[i] == elementId) {
+        relations.add(new _Relation(
+            unitIndex.usedElementKinds[i],
+            unitIndex.usedElementOffsets[i],
+            unitIndex.usedElementLengths[i],
+            unitIndex.usedElementIsQualifiedFlags[i]));
+      }
+    }
+    return relations;
+  }
+
   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);
@@ skipping 26 matching lines @@
     // 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;
+  final List<_Relation> relations;
 
-  _ElementIndexAssert(this.test, this.element);
+  _ElementIndexAssert(this.test, this.element, this.relations);
+
+  void hasRelationCount(int expectedCount) {
+    expect(relations, hasLength(expectedCount));
+  }
 
   void isAncestorOf(String search, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_ANCESTOR_OF,
+    test._assertHasRelation(
+        element,
+        relations,
+        IndexRelationKind.IS_ANCESTOR_OF,
         test._expectedLocation(search, false, length: length));
   }
 
   void isExtendedAt(String search, bool isQualified, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_EXTENDED_BY,
+    test._assertHasRelation(
+        element,
+        relations,
+        IndexRelationKind.IS_EXTENDED_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
 
   void isImplementedAt(String search, bool isQualified, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_IMPLEMENTED_BY,
+    test._assertHasRelation(
+        element,
+        relations,
+        IndexRelationKind.IS_IMPLEMENTED_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
 
   void isInvokedAt(String search, bool isQualified, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_INVOKED_BY,
+    test._assertHasRelation(element, relations, IndexRelationKind.IS_INVOKED_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
 
   void isMixedInAt(String search, bool isQualified, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_MIXED_IN_BY,
+    test._assertHasRelation(
+        element,
+        relations,
+        IndexRelationKind.IS_MIXED_IN_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
 
   void isReferencedAt(String search, bool isQualified, {int length}) {
-    test._assertHasRelation(element, IndexRelationKind.IS_REFERENCED_BY,
+    test._assertHasRelation(
+        element,
+        relations,
+        IndexRelationKind.IS_REFERENCED_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
 }
 
 class _NameIndexAssert {
   final PackageIndexAssemblerTest test;
   final String name;
 
   _NameIndexAssert(this.test, this.name);
 
@@ skipping 10 matching lines @@
   void isNotReferencedAt(String search, {int length}) {
     test._assertUsedName(name, IndexRelationKind.IS_REFERENCED_BY,
         test._expectedLocation(search, true, length: length), true);
   }
 
   void isReferencedAt(String search, {int length}) {
     test._assertUsedName(name, IndexRelationKind.IS_REFERENCED_BY,
         test._expectedLocation(search, true, length: length), false);
   }
 }
+
+class _Relation {
+  final IndexRelationKind kind;
+  final int offset;
+  final int length;
+  final bool isQualified;
+
+  _Relation(this.kind, this.offset, this.length, this.isQualified);
+
+  @override
+  String toString() {
+    return '_Relation{kind: $kind, offset: $offset, length: $length, '
+        'isQualified: $isQualified}';
+  }
+}