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

pkg/analysis_server/lib/src/services/index/index_contributor.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 services.src.index.index_contributor;
 
 import 'dart:collection' show Queue;
 
 import 'package:analysis_server/plugin/index/index_core.dart';
 import 'package:analysis_server/src/services/correction/namespace.dart';
 import 'package:analysis_server/src/services/index/index.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/java_engine.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
  * An [IndexContributor] that contributes relationships for Dart files.
  */
 class DartIndexContributor extends IndexContributor {
   @override
   void contributeTo(IndexStore store, AnalysisContext context, Object object) {
     if (store is InternalIndexStore && object is CompilationUnit) {
       _IndexContributor contributor = new _IndexContributor(store);
       object.accept(contributor);
     }
   }
 }
 
 /**
  * Visits a resolved AST and adds relationships into [InternalIndexStore].
  */
 class _IndexContributor extends GeneralizingAstVisitor {
   final InternalIndexStore _store;
 
+  CompilationUnitElement _unitElement;
   LibraryElement _libraryElement;
 
   Map<ImportElement, Set<Element>> _importElementsMap = {};
 
   /**
    * A stack whose top element (the element with the largest index) is an
    * element representing the inner-most enclosing scope.
    */
   Queue<Element> _elementStack = new Queue();
 
@@ skipping 129 matching lines @@
         }
       }
       super.visitClassTypeAlias(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
-    CompilationUnitElement unitElement = node.element;
-    if (unitElement != null) {
-      _elementStack.add(unitElement);
-      _libraryElement = unitElement.enclosingElement;
+    _unitElement = node.element;
+    if (_unitElement != null) {
+      _elementStack.add(_unitElement);
+      _libraryElement = _unitElement.enclosingElement;
       if (_libraryElement != null) {
         super.visitCompilationUnit(node);
       }
     }
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement element = node.element;
     enterScope(element);
@@ skipping 69 matching lines @@
     }
   }
 
   @override
   visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     if (element != null) {
       LibraryElement expLibrary = element.exportedLibrary;
       _recordLibraryReference(node, expLibrary);
     }
+    _recordUriFileReference(node);
     super.visitExportDirective(node);
   }
 
   @override
   visitFormalParameter(FormalParameter node) {
     ParameterElement element = node.element;
     enterScope(element);
     try {
       super.visitFormalParameter(node);
     } finally {
@@ skipping 20 matching lines @@
     super.visitFunctionTypeAlias(node);
   }
 
   @override
   visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     if (element != null) {
       LibraryElement impLibrary = element.importedLibrary;
       _recordLibraryReference(node, impLibrary);
     }
+    _recordUriFileReference(node);
     super.visitImportDirective(node);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
       Token operator = node.leftBracket;
       LocationImpl location =
           _createLocationForToken(operator, element != null);
@@ skipping 36 matching lines @@
     _recordImportElementReferenceWithoutPrefix(name);
     super.visitMethodInvocation(node);
   }
 
   @override
   visitPartDirective(PartDirective node) {
     Element element = node.element;
     LocationImpl location = _createLocationForNode(node.uri);
     recordRelationshipElement(
         element, IndexConstants.IS_REFERENCED_BY, location);
+    _recordUriFileReference(node);
     super.visitPartDirective(node);
   }
 
   @override
   visitPartOfDirective(PartOfDirective node) {
     LocationImpl location = _createLocationForNode(node.libraryName);
     recordRelationshipElement(
         node.element, IndexConstants.IS_REFERENCED_BY, location);
   }
 
@@ skipping 395 matching lines @@
       IndexableElement indexable = new IndexableElement(element);
       int offset = element.nameOffset;
       int length = element.nameLength;
       LocationImpl location = new LocationImpl(indexable, offset, length);
       recordRelationshipElement(
           _libraryElement, IndexConstants.DEFINES, location);
       _store.recordTopLevelDeclaration(element);
     }
   }
 
+  void _recordUriFileReference(UriBasedDirective directive) {
+    Source source = directive.source;
+    if (source != null) {
+      LocationImpl location = new LocationImpl(
+          new IndexableFile(_unitElement.source.fullName),
+          directive.uri.offset,
+          directive.uri.length);
+      _store.recordRelationship(new IndexableFile(source.fullName),
+          IndexConstants.IS_REFERENCED_BY, location);
+    }
+  }
+
   /**
    * If the given expression has resolved type, returns the new location with this type.
    *
    * [location] - the base location
    * [expression] - the expression assigned at the given location
    */
   static LocationImpl _getLocationWithExpressionType(
       LocationImpl location, Expression expression) {
     if (expression != null) {
       return new LocationWithData<DartType>(location, expression.bestType);
@@ skipping 10 matching lines @@
   }
 
   /**
    * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
    */
   static bool _isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
     AstNode parent = node.parent;
     return parent is PrefixedIdentifier && parent.identifier == node;
   }
 }