Index library/part file references from import/export/part containing files.

pkg/analysis_server/test/services/index/dart_index_contributor_test.dart

 // Copyright (c) 2014, 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 test.services.src.index.dart_index_contributor;
 
 import 'package:analysis_server/plugin/index/index_core.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/index_contributor.dart';
 import 'package:analysis_server/src/services/index/index_store.dart';
 import 'package:analysis_server/src/services/index/indexable_element.dart';
+import 'package:analysis_server/src/services/index/indexable_file.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../abstract_single_unit.dart';
 import '../../utils.dart';
 
 main() {
   initializeTestEnvironment();
   defineReflectiveTests(DartUnitContributorTest);
 }
 
 void indexDartUnit(
     InternalIndexStore store, AnalysisContext context, CompilationUnit unit) {
   new DartIndexContributor().contributeTo(store, context, unit);
 }
 
 /**
  * Returns `true` if the [actual] location the same properties as [expected].
  */
 bool _equalsLocation(LocationImpl actual, ExpectedLocation expected) {
-  return _equalsLocationProperties(actual, expected.element, expected.offset,
+  return _equalsLocationProperties(actual, expected.indexable, expected.offset,
       expected.length, expected.isQualified, expected.isResolved);
 }
 
 /**
  * Returns `true` if the [actual] location the expected properties.
  */
-bool _equalsLocationProperties(LocationImpl actual, Element expectedElement,
-    int expectedOffset, int expectedLength, bool isQualified, bool isResolved) {
-  return (expectedElement == null || expectedElement == actual.element) &&
+bool _equalsLocationProperties(
+    LocationImpl actual,
+    IndexableObject expectedIndexable,
+    int expectedOffset,
+    int expectedLength,
+    bool isQualified,
+    bool isResolved) {
+  return (expectedIndexable == null || expectedIndexable == actual.indexable) &&
       expectedOffset == actual.offset &&
       expectedLength == actual.length &&
       isQualified == actual.isQualified &&
       isResolved == actual.isResolved;
 }
 
 bool _equalsRecordedRelation(
     RecordedRelation recordedRelation,
     IndexableObject expectedIndexable,
     RelationshipImpl expectedRelationship,
@@ skipping 24 matching lines @@
             LocationImpl location) {
       recordedRelations
           .add(new RecordedRelation(indexable, relationship, location));
     });
     when(store.recordTopLevelDeclaration(anyObject))
         .thenInvoke((Element element) {
       recordedTopElements.add(element);
     });
   }
 
+  void test_isReferencedBy_PrefixElement() {
+    _indexTestUnit('''
+import 'dart:async' as ppp;
+main() {
+  ppp.Future a;
+  ppp.Stream b;
+}
+''');
+    // prepare elements
+    PrefixElement element = findNodeElementAtString('ppp;');
+    Element elementA = findElement('a');
+    Element elementB = findElement('b');
+    IndexableElement indexable = new IndexableElement(element);
+    // verify
+    _assertRecordedRelation(indexable, IndexConstants.IS_REFERENCED_BY,
+        _expectedLocation(elementA, 'ppp.Future'));
+    _assertRecordedRelation(indexable, IndexConstants.IS_REFERENCED_BY,
+        _expectedLocation(elementB, 'ppp.Stream'));
+    _assertNoRecordedRelation(indexable, null, _expectedLocation(null, 'ppp;'));
+  }
+
   void test_bad_unresolvedFieldFormalParameter() {
     verifyNoTestUnitErrors = false;
     _indexTestUnit('''
 class Test {
   final field;
   Test(this.fie);
 }''');
   }
 
   void test_definesClass() {
@@ skipping 923 matching lines @@
     _assertRecordedRelation(indexableSetter, IndexConstants.IS_REFERENCED_BY,
         _expectedLocationQ(mainElement, 'field = 2; // q'));
     _assertRecordedRelation(indexableGetter, IndexConstants.IS_REFERENCED_BY,
         _expectedLocationQ(mainElement, 'field); // q'));
     _assertRecordedRelationForElement(
         fieldElement,
         IndexConstants.IS_REFERENCED_BY,
         _expectedLocation(mainElement, 'field: 3'));
   }
 
+  void test_isReferencedBy_fileOfLibrary_byImportingExportingFile() {
+    addSource('/lib.dart', '');
+    _indexTestUnit('''
+import 'lib.dart'; // 1
+export 'lib.dart'; // 2
+''');
+    // verify
+    IndexableFile libIndexableFile = new IndexableFile('/lib.dart');
+    IndexableFile testIndexableFile = new IndexableFile(testFile);
+    _assertRecordedRelationForIndexable(
+        libIndexableFile,
+        IndexConstants.IS_REFERENCED_BY,
+        new ExpectedLocation(
+            testIndexableFile,
+            testCode.indexOf("'lib.dart'; // 1"),
+            "'lib.dart'".length,
+            false,
+            true));
+    _assertRecordedRelationForIndexable(
+        libIndexableFile,
+        IndexConstants.IS_REFERENCED_BY,
+        new ExpectedLocation(
+            testIndexableFile,
+            testCode.indexOf("'lib.dart'; // 2"),
+            "'lib.dart'".length,
+            false,
+            true));
+  }
+
+  void test_isReferencedBy_fileOfPart_bySourcingFile() {
+    addSource('/part.dart', 'part of my.lib;');
+    _indexTestUnit('''
+library my.lib;
+part 'part.dart';
+''');
+    // verify
+    IndexableFile partIndexableFile = new IndexableFile('/part.dart');
+    IndexableFile testIndexableFile = new IndexableFile(testFile);
+    _assertRecordedRelationForIndexable(
+        partIndexableFile,
+        IndexConstants.IS_REFERENCED_BY,
+        new ExpectedLocation(testIndexableFile, testCode.indexOf("'part.dart'"),
+            "'part.dart'".length, false, true));
+  }
+
   void test_isReferencedBy_FunctionElement() {
     _indexTestUnit('''
 foo() {}
 main() {
   print(foo);
   print(foo());
 }
 ''');
     // prepare elements
     FunctionElement element = findElement("foo");
@@ skipping 245 matching lines @@
 }
 ''');
     // prepare elements
     Element mainElement = findElement('main');
     Element element = findElement('L');
     // verify
     _assertRecordedRelationForElement(element, IndexConstants.IS_REFERENCED_BY,
         _expectedLocation(mainElement, 'L;'));
   }
 
-  void test_isReferencedBy_libraryName() {
+  void test_isReferencedBy_libraryName_byPartOf() {
     Source libSource = addSource(
         '/lib.dart',
         '''
 library lib;
 part 'test.dart';
 ''');
     testCode = 'part of lib;';
     testSource = addSource('/test.dart', testCode);
     testUnit = resolveDartUnit(testSource, libSource);
     testUnitElement = testUnit.element;
@@ skipping 34 matching lines @@
 }
 ''');
     // prepare elements
     Element mainElement = findElement('main');
     Element element = findElement('p');
     // verify
     _assertRecordedRelationForElement(element, IndexConstants.IS_REFERENCED_BY,
         _expectedLocation(mainElement, 'p: 1'));
   }
 
-  void test_isReferencedBy_PrefixElement() {
-    _indexTestUnit('''
-import 'dart:async' as ppp;
-main() {
-  ppp.Future a;
-  ppp.Stream b;
-}
-''');
-    // prepare elements
-    PrefixElement element = findNodeElementAtString('ppp;');
-    Element elementA = findElement('a');
-    Element elementB = findElement('b');
-    IndexableElement indexable = new IndexableElement(element);
-    // verify
-    _assertRecordedRelation(indexable, IndexConstants.IS_REFERENCED_BY,
-        _expectedLocation(elementA, 'ppp.Future'));
-    _assertRecordedRelation(indexable, IndexConstants.IS_REFERENCED_BY,
-        _expectedLocation(elementB, 'ppp.Stream'));
-    _assertNoRecordedRelation(indexable, null, _expectedLocation(null, 'ppp;'));
-  }
-
   void test_isReferencedBy_TopLevelVariableElement() {
     addSource(
         '/lib.dart',
         '''
 library lib;
 var V;
 ''');
     _indexTestUnit('''
 import 'lib.dart' show V; // imp
 import 'lib.dart' as pref;
@@ skipping 204 matching lines @@
     indexDartUnit(store, context, null);
   }
 
   void test_nullUnitElement() {
     CompilationUnit unit = new CompilationUnit(null, null, [], [], null);
     indexDartUnit(store, context, unit);
   }
 
   void _assertDefinesTopLevelElement(Element element) {
     ExpectedLocation location = new ExpectedLocation(
-        element, element.nameOffset, element.nameLength, false, true);
+        new IndexableElement(element),
+        element.nameOffset,
+        element.nameLength,
+        false,
+        true);
     _assertRecordedRelationForElement(
         testLibraryElement, IndexConstants.DEFINES, location);
     expect(recordedTopElements, contains(element));
   }
 
   /**
    * Asserts that [recordedRelations] has no item with the specified properties.
    */
   void _assertNoRecordedRelation(IndexableObject expectedIndexable,
       RelationshipImpl relationship, ExpectedLocation location) {
@@ skipping 68 matching lines @@
     return _assertRecordedRelationForIndexable(new IndexableName(expectedName),
         expectedRelationship, expectedLocation);
   }
 
   ExpectedLocation _expectedLocation(Element element, String search,
       {int length: -1, bool isQualified: false, bool isResolved: true}) {
     int offset = findOffset(search);
     if (length == -1) {
       length = getLeadingIdentifierLength(search);
     }
+    IndexableObject indexable =
+        element != null ? new IndexableElement(element) : null;
     return new ExpectedLocation(
-        element, offset, length, isQualified, isResolved);
+        indexable, offset, length, isQualified, isResolved);
   }
 
   ExpectedLocation _expectedLocationQ(Element element, String search,
       {int length: -1}) {
     return _expectedLocation(element, search,
         length: length, isQualified: true);
   }
 
   ExpectedLocation _expectedLocationQU(Element element, String search,
       {int length: -1}) {
     return _expectedLocation(element, search,
         length: length, isQualified: true, isResolved: false);
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     indexDartUnit(store, context, testUnit);
   }
 }
 
 class ExpectedLocation {
-  Element element;
+  IndexableObject indexable;
   int offset;
   int length;
   bool isQualified;
   bool isResolved;
 
-  ExpectedLocation(this.element, this.offset, this.length, this.isQualified,
+  ExpectedLocation(this.indexable, this.offset, this.length, this.isQualified,
       this.isResolved);
 
   @override
   String toString() {
-    return 'ExpectedLocation(element=$element; offset=$offset; length=$length;'
+    return 'ExpectedLocation(indexable=$indexable; offset=$offset; length=$length;'
         ' isQualified=$isQualified isResolved=$isResolved)';
   }
 }
 
 class MockIndexStore extends TypedMock implements InternalIndexStore {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Information about a relation recorded into {@link IndexStore}.
  */
 class RecordedRelation {
   final IndexableObject indexable;
   final RelationshipImpl relationship;
   final LocationImpl location;
 
   RecordedRelation(this.indexable, this.relationship, this.location);
 
   @override
   String toString() {
     return 'RecordedRelation(indexable=$indexable; relationship=$relationship; '
         'location=$location; flags='
         '${location.isQualified ? "Q" : ""}'
         '${location.isResolved ? "R" : ""})';
   }
 }