IndexStore, Index and SearchEngine APIs and partial implementatons.

pkg/analyzer/lib/src/index/index.dart

Index: pkg/analyzer/lib/src/index/index.dart
diff --git a/pkg/analyzer/lib/src/index/index.dart b/pkg/analyzer/lib/src/index/index.dart
new file mode 100644
index 0000000000000000000000000000000000000000..68577a5ca525e8c66fd79992c6fc9f6bc446ce23
--- /dev/null
+++ b/pkg/analyzer/lib/src/index/index.dart
@@ -0,0 +1,1192 @@
+// 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.
+
+// This code was auto-generated, is not intended to be edited, and is subject to
+// significant change. Please see the README file for more information.
+
+library engine.src.index;
+
+import 'dart:collection' show Queue;
+
+import 'package:analyzer/index/index.dart';
+import 'package:analyzer/index/index_store.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/html.dart' as ht;
+import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source.dart';
+
+
+/**
+ * Adds data to [store] based on the resolved Dart [unit].
+ */
+void indexDartUnit(IndexStore store, AnalysisContext context,
+    CompilationUnit unit) {
+  CompilationUnitElement unitElement = unit.element;
+  bool mayIndex = store.aboutToIndexDart(context, unitElement);
+  if (!mayIndex) {
+    return;
+  }
+  unit.accept(new _IndexContributor(store));
+  unit.accept(new _AngularDartIndexContributor(store));
+  store.doneIndex();
+}
+
+
+/**
+ * Adds data to [store] based on the resolved HTML [unit].
+ */
+void indexHtmlUnit(IndexStore store, AnalysisContext context, ht.HtmlUnit unit)
+    {
+  HtmlElement unitElement = unit.element;
+  bool mayIndex = store.aboutToIndexHtml(context, unitElement);
+  if (!mayIndex) {
+    return;
+  }
+  unit.accept(new _AngularHtmlIndexContributor(store));
+  store.doneIndex();
+}
+
+
+/**
+ * Visits resolved [CompilationUnit] and adds Angular specific relationships
+ * into [IndexStore].
+ */
+class _AngularDartIndexContributor extends GeneralizingAstVisitor<Object> {
+  final IndexStore _store;
+
+  _AngularDartIndexContributor(this._store);
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement classElement = node.element;
+    if (classElement != null) {
+      List<ToolkitObjectElement> toolkitObjects = classElement.toolkitObjects;
+      for (ToolkitObjectElement object in toolkitObjects) {
+        if (object is AngularComponentElement) {
+          _indexComponent(object);
+        }
+        if (object is AngularDecoratorElement) {
+          AngularDecoratorElement directive = object;
+          _indexDirective(directive);
+        }
+      }
+    }
+    // stop visiting
+    return null;
+  }
+
+  @override
+  Object visitCompilationUnitMember(CompilationUnitMember node) => null;
+
+  void _indexComponent(AngularComponentElement component) {
+    _indexProperties(component.properties);
+  }
+
+  void _indexDirective(AngularDecoratorElement directive) {
+    _indexProperties(directive.properties);
+  }
+
+  /**
+   * Index [FieldElement] references from [AngularPropertyElement]s.
+   */
+  void _indexProperties(List<AngularPropertyElement> properties) {
+    for (AngularPropertyElement property in properties) {
+      FieldElement field = property.field;
+      if (field != null) {
+        int offset = property.fieldNameOffset;
+        if (offset == -1) {
+          continue;
+        }
+        int length = field.name.length;
+        Location location = new Location(property, offset, length);
+        // getter reference
+        if (property.propertyKind.callsGetter()) {
+          PropertyAccessorElement getter = field.getter;
+          if (getter != null) {
+            _store.recordRelationship(getter,
+                IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
+          }
+        }
+        // setter reference
+        if (property.propertyKind.callsSetter()) {
+          PropertyAccessorElement setter = field.setter;
+          if (setter != null) {
+            _store.recordRelationship(setter,
+                IndexConstants.IS_REFERENCED_BY_QUALIFIED, location);
+          }
+        }
+      }
+    }
+  }
+}
+
+
+/**
+ * Visits resolved [HtmlUnit] and adds relationships into [IndexStore].
+ */
+class _AngularHtmlIndexContributor extends _ExpressionVisitor {
+  /**
+   * The [IndexStore] to record relations into.
+   */
+  final IndexStore _store;
+
+  /**
+   * The index contributor used to index Dart [Expression]s.
+   */
+  _IndexContributor _indexContributor;
+
+  HtmlElement _htmlUnitElement;
+
+  /**
+   * Initialize a newly created Angular HTML index contributor.
+   *
+   * @param store the [IndexStore] to record relations into.
+   */
+  _AngularHtmlIndexContributor(this._store) {
+    _indexContributor = new _AngularHtmlIndexContributor_forEmbeddedDart(_store,
+        this);
+  }
+
+  @override
+  void visitExpression(Expression expression) {
+    // Formatter
+    if (expression is SimpleIdentifier) {
+      SimpleIdentifier identifier = expression;

[Brian Wilkerson, 2014/07/03 18:58:13]

I'm not sure what the value of this local variable is: 'expression' already has
the type 'SimpleIdentifier' within the then-statement.

[scheglov, 2014/07/03 19:06:16]

Fixed.

Should it be a hint?

[Brian Wilkerson, 2014/07/03 20:48:19]

Perhaps. If the original variable and the new variable are never re-assigned
within the block there shouldn't be any false positives.

+      Element element = identifier.bestElement;
+      if (element is AngularElement) {
+        _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE,
+            _createLocationForIdentifier(identifier));
+        return;
+      }
+    }
+    // index as a normal Dart expression
+    expression.accept(_indexContributor);
+  }
+
+  @override
+  Object visitHtmlUnit(ht.HtmlUnit node) {
+    _htmlUnitElement = node.element;
+    CompilationUnitElement dartUnitElement =
+        _htmlUnitElement.angularCompilationUnit;
+    _indexContributor.enterScope(dartUnitElement);
+    return super.visitHtmlUnit(node);
+  }
+
+  @override
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
+    Element element = node.element;
+    if (element != null) {
+      ht.Token nameToken = node.nameToken;
+      Location location = _createLocationForToken(nameToken);
+      _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE,
+          location);
+    }
+    return super.visitXmlAttributeNode(node);
+  }
+
+  @override
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    Element element = node.element;
+    if (element != null) {
+      // tag
+      {
+        ht.Token tagToken = node.tagToken;
+        Location location = _createLocationForToken(tagToken);
+        _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE,
+            location);
+      }
+      // maybe add closing tag range
+      ht.Token closingTag = node.closingTag;
+      if (closingTag != null) {
+        Location location = _createLocationForToken(closingTag);
+        _store.recordRelationship(element,
+            IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE, location);
+      }
+    }
+    return super.visitXmlTagNode(node);
+  }
+
+  Location _createLocationForIdentifier(SimpleIdentifier identifier) =>
+      new Location(_htmlUnitElement, identifier.offset, identifier.length);
+
+  Location _createLocationForToken(ht.Token token) => new Location(
+      _htmlUnitElement, token.offset, token.length);
+}
+
+
+class _AngularHtmlIndexContributor_forEmbeddedDart extends _IndexContributor {
+  final _AngularHtmlIndexContributor angularContributor;
+
+  _AngularHtmlIndexContributor_forEmbeddedDart(IndexStore store,
+      this.angularContributor) : super(store);
+
+  @override
+  Element peekElement() => angularContributor._htmlUnitElement;
+
+  @override
+  void recordRelationship(Element element, Relationship relationship,
+      Location location) {
+    AngularElement angularElement = AngularHtmlUnitResolver.getAngularElement(
+        element);
+    if (angularElement != null) {
+      element = angularElement;
+      relationship = IndexConstants.ANGULAR_REFERENCE;
+    }
+    super.recordRelationship(element, relationship, location);
+  }
+}
+
+
+/**
+ * Recursively visits [HtmlUnit] and every embedded [Expression].

[Brian Wilkerson, 2014/07/03 18:58:13]

"visits" --> "visits an"

[scheglov, 2014/07/03 19:06:16]

Done.

+ */
+abstract class _ExpressionVisitor extends ht.RecursiveXmlVisitor<Object> {
+  /**
+   * Visits the given [Expression]s embedded into tag or attribute.
+   *
+   * @param expression the [Expression] to visit, not `null`
+   */
+  void visitExpression(Expression expression);
+
+  @override
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
+    _visitExpressions(node.expressions);
+    return super.visitXmlAttributeNode(node);
+  }
+
+  @override
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    _visitExpressions(node.expressions);
+    return super.visitXmlTagNode(node);
+  }
+
+  /**
+   * Visits [Expression]s of the given [XmlExpression]s.
+   */
+  void _visitExpressions(List<ht.XmlExpression> expressions) {
+    for (ht.XmlExpression xmlExpression in expressions) {
+      if (xmlExpression is AngularXmlExpression) {
+        AngularXmlExpression angularXmlExpression = xmlExpression;
+        List<Expression> dartExpressions =
+            angularXmlExpression.expression.expressions;
+        for (Expression dartExpression in dartExpressions) {
+          visitExpression(dartExpression);
+        }
+      }
+      if (xmlExpression is ht.RawXmlExpression) {
+        ht.RawXmlExpression rawXmlExpression = xmlExpression;
+        visitExpression(rawXmlExpression.expression);
+      }
+    }
+  }
+}
+
+
+/**
+ * Information about [ImportElement] and place where it is referenced using
+ * [PrefixElement].
+ */
+class _ImportElementInfo {
+  ImportElement _element;
+
+  int _periodEnd = 0;
+}
+
+
+/**
+ * Visits resolved AST and adds relationships into [IndexStore].
+ */
+class _IndexContributor extends GeneralizingAstVisitor<Object> {
+  final IndexStore _store;
+
+  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();
+
+  _IndexContributor(this._store);
+
+  /**
+   * Enter a new scope represented by the given [Element].
+   */
+  void enterScope(Element element) {
+    _elementStack.addFirst(element);
+  }
+
+  /**
+   * @return the inner-most enclosing [Element], may be `null`.
+   */
+  Element peekElement() {
+    for (Element element in _elementStack) {
+      if (element != null) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Record the given relationship between the given [Element] and [Location].
+   */
+  void recordRelationship(Element element, Relationship relationship,
+      Location location) {
+    if (element != null && location != null) {
+      _store.recordRelationship(element, relationship, location);
+    }
+  }
+
+  @override
+  Object visitAssignmentExpression(AssignmentExpression node) {
+    _recordOperatorReference(node.operator, node.bestElement);
+    return super.visitAssignmentExpression(node);
+  }
+
+  @override
+  Object visitBinaryExpression(BinaryExpression node) {
+    _recordOperatorReference(node.operator, node.bestElement);
+    return super.visitBinaryExpression(node);
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement element = node.element;
+    enterScope(element);
+    try {
+      _recordElementDefinition(element, IndexConstants.DEFINES_CLASS);
+      {
+        ExtendsClause extendsClause = node.extendsClause;
+        if (extendsClause != null) {
+          TypeName superclassNode = extendsClause.superclass;
+          _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
+        } else {
+          InterfaceType superType = element.supertype;
+          if (superType != null) {
+            ClassElement objectElement = superType.element;
+            recordRelationship(objectElement, IndexConstants.IS_EXTENDED_BY,
+                _createLocationFromOffset(node.name.offset, 0));
+          }
+        }
+      }
+      {
+        WithClause withClause = node.withClause;
+        if (withClause != null) {
+          for (TypeName mixinNode in withClause.mixinTypes) {
+            _recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
+          }
+        }
+      }
+      {
+        ImplementsClause implementsClause = node.implementsClause;
+        if (implementsClause != null) {
+          for (TypeName interfaceNode in implementsClause.interfaces) {
+            _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
+          }
+        }
+      }
+      return super.visitClassDeclaration(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    ClassElement element = node.element;
+    enterScope(element);
+    try {
+      _recordElementDefinition(element, IndexConstants.DEFINES_CLASS_ALIAS);
+      {
+        TypeName superclassNode = node.superclass;
+        if (superclassNode != null) {
+          _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
+        }
+      }
+      {
+        WithClause withClause = node.withClause;
+        if (withClause != null) {
+          for (TypeName mixinNode in withClause.mixinTypes) {
+            _recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
+          }
+        }
+      }
+      {
+        ImplementsClause implementsClause = node.implementsClause;
+        if (implementsClause != null) {
+          for (TypeName interfaceNode in implementsClause.interfaces) {
+            _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
+          }
+        }
+      }
+      return super.visitClassTypeAlias(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitCompilationUnit(CompilationUnit node) {
+    CompilationUnitElement unitElement = node.element;
+    if (unitElement != null) {
+      _elementStack.add(unitElement);
+      _libraryElement = unitElement.enclosingElement;
+      if (_libraryElement != null) {
+        return super.visitCompilationUnit(node);
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ConstructorElement element = node.element;
+    // define
+    {
+      Location location;
+      if (node.name != null) {
+        int start = node.period.offset;
+        int end = node.name.end;
+        location = _createLocationFromOffset(start, end - start);
+      } else {
+        int start = node.returnType.end;
+        location = _createLocationFromOffset(start, 0);
+      }
+      recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
+    }
+    // visit children
+    enterScope(element);
+    try {
+      return super.visitConstructorDeclaration(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitConstructorName(ConstructorName node) {
+    ConstructorElement element = node.staticElement;
+    // in 'class B = A;' actually A constructors are invoked
+    if (element != null && element.isSynthetic && element.redirectedConstructor
+        != null) {
+      element = element.redirectedConstructor;
+    }
+    // prepare location
+    Location location;
+    if (node.name != null) {
+      int start = node.period.offset;
+      int end = node.name.end;
+      location = _createLocationFromOffset(start, end - start);
+    } else {
+      int start = node.type.end;
+      location = _createLocationFromOffset(start, 0);
+    }
+    // record relationship
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitConstructorName(node);
+  }
+
+  @override
+  Object visitExportDirective(ExportDirective node) {
+    ExportElement element = node.element;
+    if (element != null) {
+      LibraryElement expLibrary = element.exportedLibrary;
+      _recordLibraryReference(node, expLibrary);
+    }
+    return super.visitExportDirective(node);
+  }
+
+  @override
+  Object visitFormalParameter(FormalParameter node) {
+    ParameterElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitFormalParameter(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    Element element = node.element;
+    _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION);
+    enterScope(element);
+    try {
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    Element element = node.element;
+    _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION_TYPE);
+    return super.visitFunctionTypeAlias(node);
+  }
+
+  @override
+  Object visitImportDirective(ImportDirective node) {
+    ImportElement element = node.element;
+    if (element != null) {
+      LibraryElement impLibrary = element.importedLibrary;
+      _recordLibraryReference(node, impLibrary);
+    }
+    return super.visitImportDirective(node);
+  }
+
+  @override
+  Object visitIndexExpression(IndexExpression node) {
+    MethodElement element = node.bestElement;
+    if (element is MethodElement) {
+      Token operator = node.leftBracket;
+      Location location = _createLocationFromToken(operator);
+      recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED,
+          location);
+    }
+    return super.visitIndexExpression(node);
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitMethodInvocation(MethodInvocation node) {
+    SimpleIdentifier name = node.methodName;
+    Element element = name.bestElement;
+    if (element is MethodElement || element is PropertyAccessorElement) {
+      Location location = _createLocationFromNode(name);
+      Relationship relationship;
+      if (node.target != null) {
+        relationship = IndexConstants.IS_INVOKED_BY_QUALIFIED;
+      } else {
+        relationship = IndexConstants.IS_INVOKED_BY_UNQUALIFIED;
+      }
+      recordRelationship(element, relationship, location);
+    }
+    if (element is FunctionElement || element is VariableElement) {
+      Location location = _createLocationFromNode(name);
+      recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
+    }
+    // name invocation
+    {
+      Element nameElement = new NameElement(name.name);
+      Location location = _createLocationFromNode(name);
+      Relationship kind = element != null ?
+          IndexConstants.NAME_IS_INVOKED_BY_RESOLVED :
+          IndexConstants.NAME_IS_INVOKED_BY_UNRESOLVED;
+      _store.recordRelationship(nameElement, kind, location);
+    }
+    _recordImportElementReferenceWithoutPrefix(name);
+    return super.visitMethodInvocation(node);
+  }
+
+  @override
+  Object visitPartDirective(PartDirective node) {
+    Element element = node.element;
+    Location location = _createLocationFromNode(node.uri);
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitPartDirective(node);
+  }
+
+  @override
+  Object visitPartOfDirective(PartOfDirective node) {
+    Location location = _createLocationFromNode(node.libraryName);
+    recordRelationship(node.element, IndexConstants.IS_REFERENCED_BY, location);
+    return null;
+  }
+
+  @override
+  Object visitPostfixExpression(PostfixExpression node) {
+    _recordOperatorReference(node.operator, node.bestElement);
+    return super.visitPostfixExpression(node);
+  }
+
+  @override
+  Object visitPrefixExpression(PrefixExpression node) {
+    _recordOperatorReference(node.operator, node.bestElement);
+    return super.visitPrefixExpression(node);
+  }
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    Element nameElement = new NameElement(node.name);
+    Location location = _createLocationFromNode(node);
+    // name in declaration
+    if (node.inDeclarationContext()) {
+      recordRelationship(nameElement, IndexConstants.IS_DEFINED_BY, location);
+      return null;
+    }
+    // prepare information
+    Element element = node.bestElement;
+    // qualified name reference
+    _recordQualifiedMemberReference(node, element, nameElement, location);
+    // stop if already handled
+    if (_isAlreadyHandledName(node)) {
+      return null;
+    }
+    // record name read/write
+    {
+      bool inGetterContext = node.inGetterContext();
+      bool inSetterContext = node.inSetterContext();
+      if (inGetterContext && inSetterContext) {
+        Relationship kind = element != null ?
+            IndexConstants.NAME_IS_READ_WRITTEN_BY_RESOLVED :
+            IndexConstants.NAME_IS_READ_WRITTEN_BY_UNRESOLVED;
+        _store.recordRelationship(nameElement, kind, location);
+      } else if (inGetterContext) {
+        Relationship kind = element != null ?
+            IndexConstants.NAME_IS_READ_BY_RESOLVED :
+            IndexConstants.NAME_IS_READ_BY_UNRESOLVED;
+        _store.recordRelationship(nameElement, kind, location);
+      } else if (inSetterContext) {
+        Relationship kind = element != null ?
+            IndexConstants.NAME_IS_WRITTEN_BY_RESOLVED :
+            IndexConstants.NAME_IS_WRITTEN_BY_UNRESOLVED;
+        _store.recordRelationship(nameElement, kind, location);
+      }
+    }
+    // record specific relations
+    if (element is ClassElement || element is FunctionElement || element is
+        FunctionTypeAliasElement || element is LabelElement || element is
+        TypeParameterElement) {
+      recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    } else if (element is FieldElement) {
+      location = _getLocationWithInitializerType(node, location);
+      recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    } else if (element is FieldFormalParameterElement) {
+      FieldFormalParameterElement fieldParameter = element;
+      FieldElement field = fieldParameter.field;
+      recordRelationship(field, IndexConstants.IS_REFERENCED_BY_QUALIFIED,
+          location);
+    } else if (element is PrefixElement) {
+      _recordImportElementReferenceWithPrefix(node);
+    } else if (element is PropertyAccessorElement || element is MethodElement) {
+      location = _getLocationWithTypeAssignedToField(node, element, location);
+      if (node.isQualified) {
+        recordRelationship(element, IndexConstants.IS_REFERENCED_BY_QUALIFIED,
+            location);
+      } else {
+        recordRelationship(element, IndexConstants.IS_REFERENCED_BY_UNQUALIFIED,
+            location);
+      }
+    } else if (element is ParameterElement || element is LocalVariableElement) {
+      bool inGetterContext = node.inGetterContext();
+      bool inSetterContext = node.inSetterContext();
+      if (inGetterContext && inSetterContext) {
+        recordRelationship(element, IndexConstants.IS_READ_WRITTEN_BY,
+            location);
+      } else if (inGetterContext) {
+        recordRelationship(element, IndexConstants.IS_READ_BY, location);
+      } else if (inSetterContext) {
+        recordRelationship(element, IndexConstants.IS_WRITTEN_BY, location);
+      } else {
+        recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+      }
+    }
+    _recordImportElementReferenceWithoutPrefix(node);
+    return super.visitSimpleIdentifier(node);
+  }
+
+  @override
+  Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    ConstructorElement element = node.staticElement;
+    Location location;
+    if (node.constructorName != null) {
+      int start = node.period.offset;
+      int end = node.constructorName.end;
+      location = _createLocationFromOffset(start, end - start);
+    } else {
+      int start = node.keyword.end;
+      location = _createLocationFromOffset(start, 0);
+    }
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitSuperConstructorInvocation(node);
+  }
+
+  @override
+  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    VariableDeclarationList variables = node.variables;
+    for (VariableDeclaration variableDeclaration in variables.variables) {
+      Element element = variableDeclaration.element;
+      _recordElementDefinition(element, IndexConstants.DEFINES_VARIABLE);
+    }
+    return super.visitTopLevelVariableDeclaration(node);
+  }
+
+  @override
+  Object visitTypeParameter(TypeParameter node) {
+    TypeParameterElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitTypeParameter(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    VariableElement element = node.element;
+    // record declaration
+    {
+      SimpleIdentifier name = node.name;
+      Location location = _createLocationFromNode(name);
+      location = _getLocationWithExpressionType(location, node.initializer);
+      recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
+    }
+    // visit
+    enterScope(element);
+    try {
+      return super.visitVariableDeclaration(node);
+    } finally {
+      _exitScope();
+    }
+  }
+
+  @override
+  Object visitVariableDeclarationList(VariableDeclarationList node) {
+    NodeList<VariableDeclaration> variables = node.variables;
+    if (variables != null) {
+      // use first VariableDeclaration as Element for Location(s) in type
+      {
+        TypeName type = node.type;
+        if (type != null) {
+          for (VariableDeclaration variableDeclaration in variables) {
+            enterScope(variableDeclaration.element);
+            try {
+              type.accept(this);
+            } finally {
+              _exitScope();
+            }
+            // only one iteration
+            break;
+          }
+        }
+      }
+      // visit variables
+      variables.accept(this);
+    }
+    return null;
+  }
+
+  /**
+   * @return the [Location] representing location of the [AstNode].
+   */
+  Location _createLocationFromNode(AstNode node) => _createLocationFromOffset(
+      node.offset, node.length);
+
+  /**
+   * @param offset the offset of the location within [Source]
+   * @param length the length of the location
+   * @return the [Location] representing the given offset and length within the inner-most
+   *         [Element].
+   */
+  Location _createLocationFromOffset(int offset, int length) {
+    Element element = peekElement();
+    return new Location(element, offset, length);
+  }
+
+  /**
+   * @return the [Location] representing location of the [Token].
+   */
+  Location _createLocationFromToken(Token token) => _createLocationFromOffset(
+      token.offset, token.length);
+
+  /**
+   * Exit the current scope.
+   */
+  void _exitScope() {
+    _elementStack.removeFirst();
+  }
+
+  /**
+   * @return `true` if given node already indexed as more interesting reference, so it should
+   *         not be indexed again.
+   */
+  bool _isAlreadyHandledName(SimpleIdentifier node) {
+    AstNode parent = node.parent;
+    if (parent is MethodInvocation) {
+      return identical(parent.methodName, node);
+    }
+    return false;
+  }
+
+  /**
+   * Records the [Element] definition in the library and universe.
+   */
+  void _recordElementDefinition(Element element, Relationship relationship) {
+    Location location = createLocation(element);
+    recordRelationship(_libraryElement, relationship, location);
+    recordRelationship(IndexConstants.UNIVERSE, relationship, location);
+  }
+
+  /**
+   * Records [ImportElement] that declares given prefix and imports library with element used
+   * with given prefix node.
+   */
+  void _recordImportElementReferenceWithPrefix(SimpleIdentifier prefixNode) {
+    _ImportElementInfo info = getImportElementInfo(prefixNode);
+    if (info != null) {
+      int offset = prefixNode.offset;
+      int length = info._periodEnd - offset;
+      Location location = _createLocationFromOffset(offset, length);
+      recordRelationship(info._element, IndexConstants.IS_REFERENCED_BY,
+          location);
+    }
+  }
+
+  /**
+   * Records [ImportElement] reference if given [SimpleIdentifier] references some
+   * top-level element and not qualified with import prefix.
+   */
+  void _recordImportElementReferenceWithoutPrefix(SimpleIdentifier node) {
+    if (_isIdentifierInImportCombinator(node)) {
+      return;
+    }
+    if (_isIdentifierInPrefixedIdentifier(node)) {
+      return;
+    }
+    Element element = node.staticElement;
+    ImportElement importElement = _internalGetImportElement(_libraryElement,
+        null, element, _importElementsMap);
+    if (importElement != null) {
+      Location location = _createLocationFromOffset(node.offset, 0);
+      recordRelationship(importElement, IndexConstants.IS_REFERENCED_BY,
+          location);
+    }
+  }
+
+  /**
+   * Records reference to defining [CompilationUnitElement] of the given
+   * [LibraryElement].
+   */
+  void _recordLibraryReference(UriBasedDirective node, LibraryElement library) {
+    if (library != null) {
+      Location location = _createLocationFromNode(node.uri);
+      recordRelationship(library.definingCompilationUnit,
+          IndexConstants.IS_REFERENCED_BY, location);
+    }
+  }
+
+  /**
+   * Record reference to the given operator [Element] and name.
+   */
+  void _recordOperatorReference(Token operator, Element element) {
+    // prepare location
+    Location location = _createLocationFromToken(operator);
+    // record name reference
+    {
+      String name = operator.lexeme;
+      if (name == "++") {
+        name = "+";
+      }
+      if (name == "--") {
+        name = "-";
+      }
+      if (StringUtilities.endsWithChar(name, 0x3D) && name != "==") {
+        name = name.substring(0, name.length - 1);
+      }
+      Element nameElement = new NameElement(name);
+      Relationship relationship = element != null ?
+          IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED :
+          IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
+      recordRelationship(nameElement, relationship, location);
+    }
+    // record element reference
+    if (element != null) {
+      recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED,
+          location);
+    }
+  }
+
+  /**
+   * Records reference if the given [SimpleIdentifier] looks like a qualified property access
+   * or method invocation.
+   */
+  void _recordQualifiedMemberReference(SimpleIdentifier node, Element element,
+      Element nameElement, Location location) {
+    if (node.isQualified) {
+      Relationship relationship = element != null ?
+          IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED :
+          IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
+      recordRelationship(nameElement, relationship, location);
+    }
+  }
+
+  /**
+   * Records extends/implements relationships between given [ClassElement] and [Type] of
+   * "superNode".
+   */
+  void _recordSuperType(TypeName superNode, Relationship relationship) {
+    if (superNode != null) {
+      Identifier superName = superNode.name;
+      if (superName != null) {
+        Element superElement = superName.staticElement;
+        recordRelationship(superElement, relationship, _createLocationFromNode(
+            superNode));
+      }
+    }
+  }
+
+  /**
+   * @return the [Location] representing location of the [Element].
+   */
+  static Location createLocation(Element element) {
+    if (element != null) {
+      int offset = element.nameOffset;
+      int length = element.displayName.length;
+      return new Location(element, offset, length);
+    }
+    return null;
+  }
+
+  /**
+   * @return the [ImportElement] that is referenced by this node with [PrefixElement],
+   *         may be `null`.
+   */
+  static ImportElement getImportElement(SimpleIdentifier prefixNode) {
+    _ImportElementInfo info = getImportElementInfo(prefixNode);
+    return info != null ? info._element : null;
+  }
+
+  /**
+   * @return the [ImportElementInfo] with [ImportElement] that is referenced by this
+   *         node with [PrefixElement], may be `null`.
+   */
+  static _ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
+    _ImportElementInfo info = new _ImportElementInfo();
+    // prepare environment
+    AstNode parent = prefixNode.parent;
+    CompilationUnit unit = prefixNode.getAncestor((node) => node is
+        CompilationUnit);
+    LibraryElement libraryElement = unit.element.library;
+    // prepare used element
+    Element usedElement = null;
+    if (parent is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent;
+      if (identical(prefixed.prefix, prefixNode)) {
+        usedElement = prefixed.staticElement;
+        info._periodEnd = prefixed.period.end;
+      }
+    }
+    if (parent is MethodInvocation) {
+      MethodInvocation invocation = parent;
+      if (identical(invocation.target, prefixNode)) {
+        usedElement = invocation.methodName.staticElement;
+        info._periodEnd = invocation.period.end;
+      }
+    }
+    // we need used Element
+    if (usedElement == null) {
+      return null;
+    }
+    // find ImportElement
+    String prefix = prefixNode.name;
+    Map<ImportElement, Set<Element>> importElementsMap = {};
+    info._element = _internalGetImportElement(libraryElement, prefix,
+        usedElement, importElementsMap);
+    if (info._element == null) {
+      return null;
+    }
+    return info;
+  }
+
+  /**
+   * If the given expression has resolved type, returns the new location with this type.
+   *
+   * @param location the base location
+   * @param expression the expression assigned at the given location
+   */
+  static Location _getLocationWithExpressionType(Location location,
+      Expression expression) {
+    if (expression != null) {
+      return new LocationWithData<DartType>(location, expression.bestType);
+    }
+    return location;
+  }
+
+  /**
+   * If the given node is the part of the [ConstructorFieldInitializer], returns location with
+   * type of the initializer expression.
+   */
+  static Location _getLocationWithInitializerType(SimpleIdentifier node,
+      Location location) {
+    if (node.parent is ConstructorFieldInitializer) {
+      ConstructorFieldInitializer initializer = node.parent as
+          ConstructorFieldInitializer;
+      if (identical(initializer.fieldName, node)) {
+        location = _getLocationWithExpressionType(location,
+            initializer.expression);
+      }
+    }
+    return location;
+  }
+
+  /**
+   * If the given identifier has a synthetic [PropertyAccessorElement], i.e. accessor for
+   * normal field, and it is LHS of assignment, then include [Type] of the assigned value into
+   * the [Location].
+   *
+   * @param identifier the identifier to record location
+   * @param element the element of the identifier
+   * @param location the raw location
+   * @return the [Location] with the type of the assigned value
+   */
+  static Location
+      _getLocationWithTypeAssignedToField(SimpleIdentifier identifier,
+      Element element, Location location) {
+    // we need accessor
+    if (element is! PropertyAccessorElement) {
+      return location;
+    }
+    PropertyAccessorElement accessor = element as PropertyAccessorElement;
+    // should be setter
+    if (!accessor.isSetter) {
+      return location;
+    }
+    // accessor should be synthetic, i.e. field normal
+    if (!accessor.isSynthetic) {
+      return location;
+    }
+    // should be LHS of assignment
+    AstNode parent;
+    {
+      AstNode node = identifier;
+      parent = node.parent;
+      // new T().field = x;
+      if (parent is PropertyAccess) {
+        PropertyAccess propertyAccess = parent as PropertyAccess;
+        if (identical(propertyAccess.propertyName, node)) {
+          node = propertyAccess;
+          parent = propertyAccess.parent;
+        }
+      }
+      // obj.field = x;
+      if (parent is PrefixedIdentifier) {
+        PrefixedIdentifier prefixedIdentifier = parent as PrefixedIdentifier;
+        if (identical(prefixedIdentifier.identifier, node)) {
+          node = prefixedIdentifier;
+          parent = prefixedIdentifier.parent;
+        }
+      }
+    }
+    // OK, remember the type
+    if (parent is AssignmentExpression) {
+      AssignmentExpression assignment = parent as AssignmentExpression;
+      Expression rhs = assignment.rightHandSide;
+      location = _getLocationWithExpressionType(location, rhs);
+    }
+    // done
+    return location;
+  }
+
+  /**
+   * @return the [ImportElement] that declares given [PrefixElement] and imports library
+   *         with given "usedElement".
+   */
+  static ImportElement _internalGetImportElement(LibraryElement libraryElement,
+      String prefix, Element usedElement, Map<ImportElement,
+      Set<Element>> importElementsMap) {
+    // validate Element
+    if (usedElement == null) {
+      return null;
+    }
+    if (usedElement.enclosingElement is! CompilationUnitElement) {
+      return null;
+    }
+    LibraryElement usedLibrary = usedElement.library;
+    // find ImportElement that imports used library with used prefix
+    List<ImportElement> candidates = null;
+    for (ImportElement importElement in libraryElement.imports) {
+      // required library
+      if (importElement.importedLibrary != usedLibrary) {
+        continue;
+      }
+      // required prefix
+      PrefixElement prefixElement = importElement.prefix;
+      if (prefix == null) {
+        if (prefixElement != null) {
+          continue;
+        }
+      } else {
+        if (prefixElement == null) {
+          continue;
+        }
+        if (prefix != prefixElement.name) {
+          continue;
+        }
+      }
+      // no combinators => only possible candidate
+      if (importElement.combinators.length == 0) {
+        return importElement;
+      }
+      // OK, we have candidate
+      if (candidates == null) {
+        candidates = [];
+      }
+      candidates.add(importElement);
+    }
+    // no candidates, probably element is defined in this library
+    if (candidates == null) {
+      return null;
+    }
+    // one candidate
+    if (candidates.length == 1) {
+      return candidates[0];
+    }
+    // ensure that each ImportElement has set of elements
+    for (ImportElement importElement in candidates) {
+      if (importElementsMap.containsKey(importElement)) {
+        continue;
+      }
+      Namespace namespace = new NamespaceBuilder(
+          ).createImportNamespaceForDirective(importElement);
+      Set<Element> elements = new Set();
+      importElementsMap[importElement] = elements;
+    }
+    // use import namespace to choose correct one
+    for (MapEntry<ImportElement, Set<Element>> entry in getMapEntrySet(
+        importElementsMap)) {
+      if (entry.getValue().contains(usedElement)) {
+        return entry.getKey();
+      }
+    }
+    // not found
+    return null;
+  }
+
+  /**
+   * @return `true` if given "node" is part of an import [Combinator].
+   */
+  static bool _isIdentifierInImportCombinator(SimpleIdentifier node) {
+    AstNode parent = node.parent;
+    return parent is Combinator;
+  }
+
+  /**
+   * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
+   */
+  static bool _isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
+    AstNode parent = node.parent;
+    return parent is PrefixedIdentifier && identical(parent.identifier, node);
+  }
+}