Translate index.

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

+// 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.index;
+
+import 'dart:collection' show Queue;
+import 'java_core.dart';
+import 'source.dart';
+import 'scanner.dart' show Token;
+import 'ast.dart';
+import 'element.dart';
+import 'resolver.dart' show Namespace, NamespaceBuilder;
+import 'engine.dart' show AnalysisEngine, AnalysisContext, InstrumentedAnalysisContextImpl;
+import 'html.dart' as ht;
+
+/**
+ * Instances of the [RemoveSourceOperation] implement an operation that removes from the index
+ * any data based on the content of a specified source.
+ *
+ * @coverage dart.engine.index
+ */
+class RemoveSourceOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  IndexStore _indexStore;
+
+  /**
+   * The context in which source being removed.
+   */
+  AnalysisContext _context;
+
+  /**
+   * The source being removed.
+   */
+  final Source source;
+
+  /**
+   * Initialize a newly created operation that will remove the specified resource.
+   *
+   * @param indexStore the index store against which this operation is being run
+   * @param context the [AnalysisContext] to remove source in
+   * @param source the [Source] to remove from index
+   */
+  RemoveSourceOperation(IndexStore indexStore, AnalysisContext context, this.source) {
+    this._indexStore = indexStore;
+    this._context = context;
+  }
+
+  bool get isQuery => false;
+
+  void performOperation() {
+    {
+      _indexStore.removeSource(_context, source);
+    }
+  }
+
+  bool removeWhenSourceRemoved(Source source) => false;
+
+  String toString() => "RemoveSource(${source.fullName})";
+}
+
+/**
+ * The interface [IndexOperation] defines the behavior of objects used to perform operations
+ * on an index.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class IndexOperation {
+  /**
+   * Return `true` if this operation returns information from the index.
+   *
+   * @return `true` if this operation returns information from the index
+   */
+  bool get isQuery;
+
+  /**
+   * Perform the operation implemented by this operation.
+   */
+  void performOperation();
+
+  /**
+   * Return `true` if this operation should be removed from the operation queue when the
+   * given resource has been removed.
+   *
+   * @param source the [Source] that has been removed
+   * @return `true` if this operation should be removed from the operation queue as a
+   *         result of removing the resource
+   */
+  bool removeWhenSourceRemoved(Source source);
+}
+
+/**
+ * [IndexStore] which keeps full index in memory.
+ *
+ * @coverage dart.engine.index
+ */
+class MemoryIndexStoreImpl implements MemoryIndexStore {
+  static Object _WEAK_SET_VALUE = new Object();
+
+  /**
+   * When logging is on, [AnalysisEngine] actually creates
+   * [InstrumentedAnalysisContextImpl], which wraps [AnalysisContextImpl] used to create
+   * actual [Element]s. So, in index we have to unwrap [InstrumentedAnalysisContextImpl]
+   * when perform any operation.
+   */
+  static AnalysisContext unwrapContext(AnalysisContext context) {
+    if (context is InstrumentedAnalysisContextImpl) {
+      context = (context as InstrumentedAnalysisContextImpl).basis;
+    }
+    return context;
+  }
+
+  /**
+   * @return the [Source] of the enclosing [LibraryElement], may be `null`.
+   */
+  static Source getLibrarySourceOrNull(Element element) {
+    LibraryElement library = element.library;
+    return library != null ? library.source : null;
+  }
+
+  /**
+   * We add [AnalysisContext] to this weak set to ensure that we don't continue to add
+   * relationships after some context was removed using [removeContext].
+   */
+  Expando _removedContexts = new Expando();
+
+  /**
+   * This map is used to canonicalize equal keys.
+   */
+  Map<MemoryIndexStoreImpl_ElementRelationKey, MemoryIndexStoreImpl_ElementRelationKey> _canonicalKeys = {};
+
+  /**
+   * The mapping of [ElementRelationKey] to the [Location]s, one-to-many.
+   */
+  Map<MemoryIndexStoreImpl_ElementRelationKey, Set<Location>> _keyToLocations = {};
+
+  /**
+   * The mapping of [Source] to the [ElementRelationKey]s. It is used in
+   * [removeSource] to identify keys to remove from
+   * [keyToLocations].
+   */
+  Map<AnalysisContext, Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>>> _contextToSourceToKeys = {};
+
+  /**
+   * The mapping of [Source] to the [Location]s existing in it. It is used in
+   * [clearSource0] to identify locations to remove from
+   * [keyToLocations].
+   */
+  Map<AnalysisContext, Map<MemoryIndexStoreImpl_Source2, List<Location>>> _contextToSourceToLocations = {};
+
+  /**
+   * The mapping of library [Source] to the [Source]s of part units.
+   */
+  Map<AnalysisContext, Map<Source, Set<Source>>> _contextToLibraryToUnits = {};
+
+  /**
+   * The mapping of unit [Source] to the [Source]s of libraries it is used in.
+   */
+  Map<AnalysisContext, Map<Source, Set<Source>>> _contextToUnitToLibraries = {};
+
+  int _sourceCount = 0;
+
+  int _keyCount = 0;
+
+  int _locationCount = 0;
+
+  bool aboutToIndex(AnalysisContext context, CompilationUnitElement unitElement) {
+    context = unwrapContext(context);
+    if (isRemovedContext(context)) {
+      return false;
+    }
+    if (unitElement == null) {
+      return false;
+    }
+    LibraryElement libraryElement = unitElement.library;
+    if (libraryElement == null) {
+      return false;
+    }
+    CompilationUnitElement definingUnitElement = libraryElement.definingCompilationUnit;
+    if (definingUnitElement == null) {
+      return false;
+    }
+    Source library = definingUnitElement.source;
+    Source unit = unitElement.source;
+    if (unit == library) {
+      Set<Source> newParts = new Set();
+      for (CompilationUnitElement part in libraryElement.parts) {
+        newParts.add(part.source);
+      }
+      Map<Source, Set<Source>> libraryToUnits = _contextToLibraryToUnits[context];
+      if (libraryToUnits == null) {
+        libraryToUnits = {};
+        _contextToLibraryToUnits[context] = libraryToUnits;
+      }
+      Set<Source> oldParts = libraryToUnits[library];
+      if (oldParts != null) {
+        Set<Source> noParts = oldParts.difference(newParts);
+        for (Source noPart in noParts) {
+          removeLocations(context, library, noPart);
+        }
+      }
+      libraryToUnits[library] = newParts;
+    }
+    Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
+    if (unitToLibraries == null) {
+      unitToLibraries = {};
+      _contextToUnitToLibraries[context] = unitToLibraries;
+    }
+    Set<Source> libraries = unitToLibraries[unit];
+    if (libraries == null) {
+      libraries = new Set();
+      unitToLibraries[unit] = libraries;
+    }
+    libraries.add(library);
+    removeLocations(context, library, unit);
+    {
+      Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
+      if (sourceToKeys != null) {
+        MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
+        sourceToKeys.remove(source2);
+      }
+    }
+    return true;
+  }
+
+  bool aboutToIndex2(AnalysisContext context, Source source) {
+    context = unwrapContext(context);
+    if (isRemovedContext(context)) {
+      return false;
+    }
+    removeLocations(context, source, source);
+    {
+      Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
+      if (sourceToKeys != null) {
+        MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(source, source);
+        sourceToKeys.remove(source2);
+      }
+    }
+    return true;
+  }
+
+  List<Location> getRelationships(Element element, Relationship relationship) {
+    MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
+    Set<Location> locations = _keyToLocations[key];
+    if (locations != null) {
+      return new List.from(locations);
+    }
+    return Location.EMPTY_ARRAY;
+  }
+
+  String get statistics => "${_locationCount} relationships in ${_keyCount} keys in ${_sourceCount} sources";
+
+  int internalGetKeyCount() => _keyToLocations.length;
+
+  int internalGetLocationCount() {
+    int count = 0;
+    for (Set<Location> locations in _keyToLocations.values) {
+      count += locations.length;
+    }
+    return count;
+  }
+
+  int internalGetLocationCount2(AnalysisContext context) {
+    context = unwrapContext(context);
+    int count = 0;
+    for (Set<Location> locations in _keyToLocations.values) {
+      for (Location location in locations) {
+        if (identical(location.element.context, context)) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+
+  int internalGetSourceKeyCount(AnalysisContext context) {
+    int count = 0;
+    Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
+    if (sourceToKeys != null) {
+      for (Set<MemoryIndexStoreImpl_ElementRelationKey> keys in sourceToKeys.values) {
+        count += keys.length;
+      }
+    }
+    return count;
+  }
+
+  void recordRelationship(Element element, Relationship relationship, Location location) {
+    if (element == null || location == null) {
+      return;
+    }
+    location = location.clone();
+    if (element is Member) {
+      element = (element as Member).baseElement;
+    }
+    AnalysisContext elementContext = element.context;
+    AnalysisContext locationContext = location.element.context;
+    Source elementSource = element.source;
+    Source locationSource = location.element.source;
+    Source elementLibrarySource = getLibrarySourceOrNull(element);
+    Source locationLibrarySource = getLibrarySourceOrNull(location.element);
+    if (locationContext == null) {
+      return;
+    }
+    if (locationSource == null) {
+      return;
+    }
+    if (elementContext == null && element is! NameElementImpl && element is! UniverseElementImpl) {
+      return;
+    }
+    if (elementSource == null && element is! NameElementImpl && element is! UniverseElementImpl) {
+      return;
+    }
+    if (isRemovedContext(elementContext)) {
+      return;
+    }
+    if (isRemovedContext(locationContext)) {
+      return;
+    }
+    MemoryIndexStoreImpl_ElementRelationKey key = getCanonicalKey(element, relationship);
+    {
+      Set<Location> locations = _keyToLocations.remove(key);
+      if (locations == null) {
+        locations = createLocationIdentitySet();
+      } else {
+        _keyCount--;
+      }
+      _keyToLocations[key] = locations;
+      _keyCount++;
+      locations.add(location);
+      _locationCount++;
+    }
+    location.internalKey = key;
+    MemoryIndexStoreImpl_Source2 elementSource2 = new MemoryIndexStoreImpl_Source2(elementLibrarySource, elementSource);
+    MemoryIndexStoreImpl_Source2 locationSource2 = new MemoryIndexStoreImpl_Source2(locationLibrarySource, locationSource);
+    {
+      Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[elementContext];
+      if (sourceToKeys == null) {
+        sourceToKeys = {};
+        _contextToSourceToKeys[elementContext] = sourceToKeys;
+      }
+      Set<MemoryIndexStoreImpl_ElementRelationKey> keys = sourceToKeys[elementSource2];
+      if (keys == null) {
+        keys = new Set();
+        sourceToKeys[elementSource2] = keys;
+        _sourceCount++;
+      }
+      keys.remove(key);
+      keys.add(key);
+    }
+    {
+      Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[locationContext];
+      if (sourceToLocations == null) {
+        sourceToLocations = {};
+        _contextToSourceToLocations[locationContext] = sourceToLocations;
+      }
+      List<Location> locations = sourceToLocations[locationSource2];
+      if (locations == null) {
+        locations = [];
+        sourceToLocations[locationSource2] = locations;
+      }
+      locations.add(location);
+    }
+  }
+
+  void removeContext(AnalysisContext context) {
+    context = unwrapContext(context);
+    if (context == null) {
+      return;
+    }
+    markRemovedContext(context);
+    removeSources(context, null);
+    _contextToSourceToKeys.remove(context);
+    _contextToSourceToLocations.remove(context);
+    _contextToLibraryToUnits.remove(context);
+    _contextToUnitToLibraries.remove(context);
+  }
+
+  void removeSource(AnalysisContext context, Source unit) {
+    context = unwrapContext(context);
+    if (context == null) {
+      return;
+    }
+    Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
+    if (unitToLibraries != null) {
+      Set<Source> libraries = unitToLibraries.remove(unit);
+      if (libraries != null) {
+        for (Source library in libraries) {
+          MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
+          removeLocations(context, library, unit);
+          Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
+          if (sourceToKeys != null) {
+            Set<MemoryIndexStoreImpl_ElementRelationKey> keys = sourceToKeys.remove(source2);
+            if (keys != null) {
+              for (MemoryIndexStoreImpl_ElementRelationKey key in keys) {
+                _canonicalKeys.remove(key);
+                Set<Location> locations = _keyToLocations.remove(key);
+                if (locations != null) {
+                  _keyCount--;
+                  _locationCount -= locations.length;
+                }
+              }
+              _sourceCount--;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  void removeSources(AnalysisContext context, SourceContainer container) {
+    context = unwrapContext(context);
+    if (context == null) {
+      return;
+    }
+    Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
+    if (sourceToKeys != null) {
+      List<MemoryIndexStoreImpl_Source2> sources = [];
+      for (MemoryIndexStoreImpl_Source2 source2 in sources) {
+        Source source = source2._unitSource;
+        if (container == null || container.contains(source)) {
+          removeSource(context, source);
+        }
+      }
+    }
+    Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[context];
+    if (sourceToLocations != null) {
+      List<MemoryIndexStoreImpl_Source2> sources = [];
+      for (MemoryIndexStoreImpl_Source2 source2 in sources) {
+        Source source = source2._unitSource;
+        if (container == null || container.contains(source)) {
+          removeSource(context, source);
+        }
+      }
+    }
+  }
+
+  /**
+   * Creates new [Set] that uses object identity instead of equals.
+   */
+  Set<Location> createLocationIdentitySet() => new Set<Location>.identity();
+
+  /**
+   * @return the canonical [ElementRelationKey] for given [Element] and
+   *         [Relationship], i.e. unique instance for this combination.
+   */
+  MemoryIndexStoreImpl_ElementRelationKey getCanonicalKey(Element element, Relationship relationship) {
+    MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
+    MemoryIndexStoreImpl_ElementRelationKey canonicalKey = _canonicalKeys[key];
+    if (canonicalKey == null) {
+      canonicalKey = key;
+      _canonicalKeys[key] = canonicalKey;
+    }
+    return canonicalKey;
+  }
+
+  /**
+   * Checks if given [AnalysisContext] is marked as removed.
+   */
+  bool isRemovedContext(AnalysisContext context) => _removedContexts[context] != null;
+
+  /**
+   * Marks given [AnalysisContext] as removed.
+   */
+  void markRemovedContext(AnalysisContext context) {
+    _removedContexts[context] = true;
+  }
+
+  /**
+   * Removes locations recorded in the given library/unit pair.
+   */
+  void removeLocations(AnalysisContext context, Source library, Source unit) {
+    MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(library, unit);
+    Map<MemoryIndexStoreImpl_Source2, List<Location>> sourceToLocations = _contextToSourceToLocations[context];
+    if (sourceToLocations != null) {
+      List<Location> sourceLocations = sourceToLocations.remove(source2);
+      if (sourceLocations != null) {
+        for (Location location in sourceLocations) {
+          MemoryIndexStoreImpl_ElementRelationKey key = location.internalKey as MemoryIndexStoreImpl_ElementRelationKey;
+          Set<Location> relLocations = _keyToLocations[key];
+          if (relLocations != null) {
+            relLocations.remove(location);
+            _locationCount--;
+            if (relLocations.isEmpty) {
+              _canonicalKeys.remove(key);
+              _keyToLocations.remove(key);
+              _keyCount--;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+class MemoryIndexStoreImpl_ElementRelationKey {
+  Element _element;
+
+  Relationship _relationship;
+
+  MemoryIndexStoreImpl_ElementRelationKey(Element element, Relationship relationship) {
+    this._element = element;
+    this._relationship = relationship;
+  }
+
+  bool operator ==(Object obj) {
+    MemoryIndexStoreImpl_ElementRelationKey other = obj as MemoryIndexStoreImpl_ElementRelationKey;
+    Element otherElement = other._element;
+    return identical(other._relationship, _relationship) && otherElement.nameOffset == _element.nameOffset && identical(otherElement.kind, _element.kind) && otherElement.displayName == _element.displayName && otherElement.source == _element.source;
+  }
+
+  int get hashCode => JavaArrays.makeHashCode([
+      _element.source,
+      _element.nameOffset,
+      _element.kind,
+      _element.displayName,
+      _relationship]);
+
+  String toString() => "${_element} ${_relationship}";
+}
+
+class MemoryIndexStoreImpl_Source2 {
+  Source _librarySource;
+
+  Source _unitSource;
+
+  MemoryIndexStoreImpl_Source2(Source librarySource, Source unitSource) {
+    this._librarySource = librarySource;
+    this._unitSource = unitSource;
+  }
+
+  bool operator ==(Object obj) {
+    if (identical(obj, this)) {
+      return true;
+    }
+    if (obj is! MemoryIndexStoreImpl_Source2) {
+      return false;
+    }
+    MemoryIndexStoreImpl_Source2 other = obj as MemoryIndexStoreImpl_Source2;
+    return other._librarySource == _librarySource && other._unitSource == _unitSource;
+  }
+
+  int get hashCode => JavaArrays.makeHashCode([_librarySource, _unitSource]);
+
+  String toString() => "${_librarySource} ${_unitSource}";
+}
+
+/**
+ * Instances of the [IndexUnitOperation] implement an operation that adds data to the index
+ * based on the resolved [CompilationUnit].
+ *
+ * @coverage dart.engine.index
+ */
+class IndexUnitOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  IndexStore _indexStore;
+
+  /**
+   * The context in which compilation unit was resolved.
+   */
+  AnalysisContext _context;
+
+  /**
+   * The compilation unit being indexed.
+   */
+  final CompilationUnit unit;
+
+  /**
+   * The element of the compilation unit being indexed.
+   */
+  CompilationUnitElement _unitElement;
+
+  /**
+   * The source being indexed.
+   */
+  Source _source;
+
+  /**
+   * Initialize a newly created operation that will index the specified unit.
+   *
+   * @param indexStore the index store against which this operation is being run
+   * @param context the context in which compilation unit was resolved
+   * @param unit the fully resolved AST structure
+   */
+  IndexUnitOperation(IndexStore indexStore, AnalysisContext context, this.unit) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this._unitElement = unit.element;
+    this._source = _unitElement.source;
+  }
+
+  /**
+   * @return the [Source] to be indexed.
+   */
+  Source get source => _source;
+
+  bool get isQuery => false;
+
+  void performOperation() {
+    {
+      try {
+        bool mayIndex = _indexStore.aboutToIndex(_context, _unitElement);
+        if (!mayIndex) {
+          return;
+        }
+        unit.accept(new IndexContributor(_indexStore));
+        unit.accept(new AngularDartIndexContributor(_indexStore));
+      } catch (exception) {
+        AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
+      }
+    }
+  }
+
+  bool removeWhenSourceRemoved(Source source) => this._source == source;
+
+  String toString() => "IndexUnitOperation(${_source.fullName})";
+}
+
+/**
+ * Recursively visits [HtmlUnit] and every embedded [Expression].
+ */
+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);
+
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
+    visitExpressions(node.expressions);
+    return super.visitXmlAttributeNode(node);
+  }
+
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    visitExpressions(node.expressions);
+    return super.visitXmlTagNode(node);
+  }
+
+  /**
+   * Visits [Expression]s of the given [EmbeddedExpression]s.
+   */
+  void visitExpressions(List<ht.EmbeddedExpression> expressions) {
+    for (ht.EmbeddedExpression embeddedExpression in expressions) {
+      Expression expression = embeddedExpression.expression;
+      visitExpression(expression);
+    }
+  }
+}
+
+/**
+ * Relationship between an element and a location. Relationships are identified by a globally unique
+ * identifier.
+ *
+ * @coverage dart.engine.index
+ */
+class Relationship {
+  /**
+   * The unique identifier for this relationship.
+   */
+  String _uniqueId;
+
+  /**
+   * A table mapping relationship identifiers to relationships.
+   */
+  static Map<String, Relationship> _RelationshipMap = {};
+
+  /**
+   * Return the relationship with the given unique identifier.
+   *
+   * @param uniqueId the unique identifier for the relationship
+   * @return the relationship with the given unique identifier
+   */
+  static Relationship getRelationship(String uniqueId) {
+    {
+      Relationship relationship = _RelationshipMap[uniqueId];
+      if (relationship == null) {
+        relationship = new Relationship(uniqueId);
+        _RelationshipMap[uniqueId] = relationship;
+      }
+      return relationship;
+    }
+  }
+
+  /**
+   * @return all registered [Relationship]s.
+   */
+  static Iterable<Relationship> values() => _RelationshipMap.values;
+
+  /**
+   * Initialize a newly created relationship to have the given unique identifier.
+   *
+   * @param uniqueId the unique identifier for this relationship
+   */
+  Relationship(String uniqueId) {
+    this._uniqueId = uniqueId;
+  }
+
+  /**
+   * Return the unique identifier for this relationship.
+   *
+   * @return the unique identifier for this relationship
+   */
+  String get identifier => _uniqueId;
+
+  String toString() => _uniqueId;
+}
+
+/**
+ * Implementation of [Index].
+ *
+ * @coverage dart.engine.index
+ */
+class IndexImpl implements Index {
+  IndexStore _store;
+
+  OperationQueue _queue;
+
+  OperationProcessor _processor;
+
+  IndexImpl(IndexStore store, OperationQueue queue, OperationProcessor processor) {
+    this._store = store;
+    this._queue = queue;
+    this._processor = processor;
+  }
+
+  void getRelationships(Element element, Relationship relationship, RelationshipCallback callback) {
+    _queue.enqueue(new GetRelationshipsOperation(_store, element, relationship, callback));
+  }
+
+  String get statistics => _store.statistics;
+
+  void indexHtmlUnit(AnalysisContext context, ht.HtmlUnit unit) {
+    if (unit == null) {
+      return;
+    }
+    if (unit.element == null) {
+      return;
+    }
+    if (unit.compilationUnitElement == null) {
+      return;
+    }
+    _queue.enqueue(new IndexHtmlUnitOperation(_store, context, unit));
+  }
+
+  void indexUnit(AnalysisContext context, CompilationUnit unit) {
+    if (unit == null) {
+      return;
+    }
+    if (unit.element == null) {
+      return;
+    }
+    _queue.enqueue(new IndexUnitOperation(_store, context, unit));
+  }
+
+  void removeContext(AnalysisContext context) {
+    _queue.enqueue(new RemoveContextOperation(_store, context));
+  }
+
+  void removeSource(AnalysisContext context, Source source) {
+    _queue.enqueue(new RemoveSourceOperation(_store, context, source));
+  }
+
+  void removeSources(AnalysisContext context, SourceContainer container) {
+    _queue.enqueue(new RemoveSourcesOperation(_store, context, container));
+  }
+
+  void run() {
+    _processor.run();
+  }
+
+  void stop() {
+    _processor.stop(false);
+  }
+}
+
+/**
+ * Instances of the [RemoveSourcesOperation] implement an operation that removes from the
+ * index any data based on the content of source belonging to a [SourceContainer].
+ *
+ * @coverage dart.engine.index
+ */
+class RemoveSourcesOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  IndexStore _indexStore;
+
+  /**
+   * The context to remove container.
+   */
+  AnalysisContext _context;
+
+  /**
+   * The source container to remove.
+   */
+  final SourceContainer container;
+
+  /**
+   * Initialize a newly created operation that will remove the specified resource.
+   *
+   * @param indexStore the index store against which this operation is being run
+   * @param context the [AnalysisContext] to remove container in
+   * @param container the [SourceContainer] to remove from index
+   */
+  RemoveSourcesOperation(IndexStore indexStore, AnalysisContext context, this.container) {
+    this._indexStore = indexStore;
+    this._context = context;
+  }
+
+  bool get isQuery => false;
+
+  void performOperation() {
+    {
+      _indexStore.removeSources(_context, container);
+    }
+  }
+
+  bool removeWhenSourceRemoved(Source source) => false;
+
+  String toString() => "RemoveSources(${container})";
+}
+
+/**
+ * The interface `UniverseElement` defines element to use when we want to request "defines"
+ * relations without specifying exact library.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class UniverseElement implements Element {
+  static final UniverseElement INSTANCE = UniverseElementImpl.INSTANCE;
+}
+
+/**
+ * Instances of the [OperationProcessor] process the operations on a single
+ * [OperationQueue]. Each processor can be run one time on a single thread.
+ *
+ * @coverage dart.engine.index
+ */
+class OperationProcessor {
+  /**
+   * The queue containing the operations to be processed.
+   */
+  OperationQueue _queue;
+
+  /**
+   * The current state of the processor.
+   */
+  ProcessorState _state = ProcessorState.READY;
+
+  /**
+   * The number of milliseconds for which the thread on which the processor is running will wait for
+   * an operation to become available if there are no operations ready to be processed.
+   */
+  static int _WAIT_DURATION = 100;
+
+  /**
+   * Initialize a newly created operation processor to process the operations on the given queue.
+   *
+   * @param queue the queue containing the operations to be processed
+   */
+  OperationProcessor(OperationQueue queue) {
+    this._queue = queue;
+  }
+
+  /**
+   * Start processing operations. If the processor is already running on a different thread, then
+   * this method will return immediately with no effect. Otherwise, this method will not return
+   * until after the processor has been stopped from a different thread or until the thread running
+   * the processor has been interrupted.
+   */
+  void run() {
+    {
+      if (_state != ProcessorState.READY) {
+        throw new IllegalStateException("Operation processors can only be run one time");
+      }
+      _state = ProcessorState.RUNNING;
+    }
+    try {
+      while (isRunning) {
+        IndexOperation operation = null;
+        {
+          operation = _queue.dequeue(_WAIT_DURATION);
+        }
+        if (operation != null) {
+          try {
+            operation.performOperation();
+          } catch (exception) {
+            AnalysisEngine.instance.logger.logError2("Exception in indexing operation: ${operation}", exception);
+          }
+        }
+      }
+    } finally {
+      {
+        _state = ProcessorState.STOPPED;
+      }
+    }
+  }
+
+  /**
+   * Stop processing operations after the current operation has completed. If the argument is
+   * `true` then this method will wait until the last operation has completed; otherwise this
+   * method might return before the last operation has completed.
+   *
+   * @param wait `true` if this method will wait until the last operation has completed before
+   *          returning
+   * @return the library files for the libraries that need to be analyzed when a new session is
+   *         started.
+   */
+  List<Source> stop(bool wait) {
+    {
+      if (identical(_state, ProcessorState.READY)) {
+        _state = ProcessorState.STOPPED;
+        return unanalyzedSources;
+      } else if (identical(_state, ProcessorState.STOPPED)) {
+        return unanalyzedSources;
+      } else if (identical(_state, ProcessorState.RUNNING)) {
+        _state = ProcessorState.STOP_REQESTED;
+      }
+    }
+    while (wait) {
+      {
+        if (identical(_state, ProcessorState.STOPPED)) {
+          return unanalyzedSources;
+        }
+      }
+      waitOneMs();
+    }
+    return unanalyzedSources;
+  }
+
+  /**
+   * Waits until processors will switch from "ready" to "running" state.
+   *
+   * @return `true` if processor is now actually in "running" state, e.g. not in "stopped"
+   *         state.
+   */
+  bool waitForRunning() {
+    while (identical(_state, ProcessorState.READY)) {
+      threadYield();
+    }
+    return identical(_state, ProcessorState.RUNNING);
+  }
+
+  /**
+   * @return the [Source]s that are not indexed yet.
+   */
+  List<Source> get unanalyzedSources {
+    Set<Source> sources = new Set();
+    for (IndexOperation operation in _queue.operations) {
+      if (operation is IndexUnitOperation) {
+        Source source = operation.source;
+        sources.add(source);
+      }
+    }
+    return new List.from(sources);
+  }
+
+  /**
+   * Return `true` if the current state is [ProcessorState#RUNNING].
+   *
+   * @return `true` if this processor is running
+   */
+  bool get isRunning {
+    {
+      return identical(_state, ProcessorState.RUNNING);
+    }
+  }
+
+  void threadYield() {
+  }
+
+  void waitOneMs() {
+  }
+}
+
+/**
+ * The enumeration <code>ProcessorState</code> represents the possible states of an operation
+ * processor.
+ */
+class ProcessorState extends Enum<ProcessorState> {
+  /**
+   * The processor is ready to be run (has not been run before).
+   */
+  static final ProcessorState READY = new ProcessorState('READY', 0);
+
+  /**
+   * The processor is currently performing operations.
+   */
+  static final ProcessorState RUNNING = new ProcessorState('RUNNING', 1);
+
+  /**
+   * The processor is currently performing operations but has been asked to stop.
+   */
+  static final ProcessorState STOP_REQESTED = new ProcessorState('STOP_REQESTED', 2);
+
+  /**
+   * The processor has stopped performing operations and cannot be used again.
+   */
+  static final ProcessorState STOPPED = new ProcessorState('STOPPED', 3);
+
+  static final List<ProcessorState> values = [READY, RUNNING, STOP_REQESTED, STOPPED];
+
+  ProcessorState(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
+ * Constants used when populating and accessing the index.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class IndexConstants {
+  /**
+   * An element used to represent the universe.
+   */
+  static final Element UNIVERSE = UniverseElement.INSTANCE;
+
+  /**
+   * The relationship used to indicate that a container (the left-operand) contains the definition
+   * of a class at a specific location (the right operand).
+   */
+  static final Relationship DEFINES_CLASS = Relationship.getRelationship("defines-class");
+
+  /**
+   * The relationship used to indicate that a container (the left-operand) contains the definition
+   * of a function at a specific location (the right operand).
+   */
+  static final Relationship DEFINES_FUNCTION = Relationship.getRelationship("defines-function");
+
+  /**
+   * The relationship used to indicate that a container (the left-operand) contains the definition
+   * of a class type alias at a specific location (the right operand).
+   */
+  static final Relationship DEFINES_CLASS_ALIAS = Relationship.getRelationship("defines-class-alias");
+
+  /**
+   * The relationship used to indicate that a container (the left-operand) contains the definition
+   * of a function type at a specific location (the right operand).
+   */
+  static final Relationship DEFINES_FUNCTION_TYPE = Relationship.getRelationship("defines-function-type");
+
+  /**
+   * The relationship used to indicate that a container (the left-operand) contains the definition
+   * of a method at a specific location (the right operand).
+   */
+  static final Relationship DEFINES_VARIABLE = Relationship.getRelationship("defines-variable");
+
+  /**
+   * The relationship used to indicate that a name (the left-operand) is defined at a specific
+   * location (the right operand).
+   */
+  static final Relationship IS_DEFINED_BY = Relationship.getRelationship("is-defined-by");
+
+  /**
+   * The relationship used to indicate that a type (the left-operand) is extended by a type at a
+   * specific location (the right operand).
+   */
+  static final Relationship IS_EXTENDED_BY = Relationship.getRelationship("is-extended-by");
+
+  /**
+   * The relationship used to indicate that a type (the left-operand) is implemented by a type at a
+   * specific location (the right operand).
+   */
+  static final Relationship IS_IMPLEMENTED_BY = Relationship.getRelationship("is-implemented-by");
+
+  /**
+   * The relationship used to indicate that a type (the left-operand) is mixed into a type at a
+   * specific location (the right operand).
+   */
+  static final Relationship IS_MIXED_IN_BY = Relationship.getRelationship("is-mixed-in-by");
+
+  /**
+   * The relationship used to indicate that a parameter or variable (the left-operand) is read at a
+   * specific location (the right operand).
+   */
+  static final Relationship IS_READ_BY = Relationship.getRelationship("is-read-by");
+
+  /**
+   * The relationship used to indicate that a parameter or variable (the left-operand) is both read
+   * and modified at a specific location (the right operand).
+   */
+  static final Relationship IS_READ_WRITTEN_BY = Relationship.getRelationship("is-read-written-by");
+
+  /**
+   * The relationship used to indicate that a parameter or variable (the left-operand) is modified
+   * (assigned to) at a specific location (the right operand).
+   */
+  static final Relationship IS_WRITTEN_BY = Relationship.getRelationship("is-written-by");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is referenced at a
+   * specific location (the right operand). This is used for everything except read/write operations
+   * for fields, parameters, and variables. Those use either [IS_REFERENCED_BY_QUALIFIED],
+   * [IS_REFERENCED_BY_UNQUALIFIED], [IS_READ_BY], [IS_WRITTEN_BY] or
+   * [IS_READ_WRITTEN_BY], as appropriate.
+   */
+  static final Relationship IS_REFERENCED_BY = Relationship.getRelationship("is-referenced-by");
+
+  /**
+   * The relationship used to indicate that an [NameElementImpl] (the left-operand) is
+   * referenced at a specific location (the right operand). This is used for qualified resolved
+   * references to methods and fields.
+   */
+  static final Relationship IS_REFERENCED_BY_QUALIFIED_RESOLVED = Relationship.getRelationship("is-referenced-by_qualified-resolved");
+
+  /**
+   * The relationship used to indicate that an [NameElementImpl] (the left-operand) is
+   * referenced at a specific location (the right operand). This is used for qualified unresolved
+   * references to methods and fields.
+   */
+  static final Relationship IS_REFERENCED_BY_QUALIFIED_UNRESOLVED = Relationship.getRelationship("is-referenced-by_qualified-unresolved");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is referenced at a
+   * specific location (the right operand). This is used for field accessors and methods.
+   */
+  static final Relationship IS_REFERENCED_BY_QUALIFIED = Relationship.getRelationship("is-referenced-by-qualified");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is referenced at a
+   * specific location (the right operand). This is used for field accessors and methods.
+   */
+  static final Relationship IS_REFERENCED_BY_UNQUALIFIED = Relationship.getRelationship("is-referenced-by-unqualified");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is invoked at a specific
+   * location (the right operand). This is used for functions.
+   */
+  static final Relationship IS_INVOKED_BY = Relationship.getRelationship("is-invoked-by");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is invoked at a specific
+   * location (the right operand). This is used for methods.
+   */
+  static final Relationship IS_INVOKED_BY_QUALIFIED = Relationship.getRelationship("is-invoked-by-qualified");
+
+  /**
+   * The relationship used to indicate that an element (the left-operand) is invoked at a specific
+   * location (the right operand). This is used for methods.
+   */
+  static final Relationship IS_INVOKED_BY_UNQUALIFIED = Relationship.getRelationship("is-invoked-by-unqualified");
+}
+
+/**
+ * Visits resolved [HtmlUnit] and adds relationships into [IndexStore].
+ *
+ * @coverage dart.engine.index
+ */
+class AngularHtmlIndexContributor extends ExpressionVisitor {
+  /**
+   * The [IndexStore] to record relations into.
+   */
+  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(IndexStore store) {
+    this._store = store;
+    _indexContributor = new IndexContributor(store);
+  }
+
+  void visitExpression(Expression expression) {
+    expression.accept(_indexContributor);
+  }
+
+  Object visitHtmlUnit(ht.HtmlUnit node) {
+    _htmlUnitElement = node.element;
+    CompilationUnitElement dartUnitElement = node.compilationUnitElement;
+    _indexContributor.enterScope(dartUnitElement);
+    return super.visitHtmlUnit(node);
+  }
+
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
+    Element element = node.element;
+    if (element != null) {
+      ht.Token nameToken = node.nameToken;
+      Location location = createLocation(nameToken);
+      _store.recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    }
+    return super.visitXmlAttributeNode(node);
+  }
+
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    Element element = node.element;
+    if (element != null) {
+      ht.Token tagToken = node.tagToken;
+      Location location = createLocation(tagToken);
+      _store.recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    }
+    return super.visitXmlTagNode(node);
+  }
+
+  Location createLocation(ht.Token token) => new Location(_htmlUnitElement, token.offset, token.length);
+}
+
+/**
+ * The interface [Index] defines the behavior of objects that maintain an index storing
+ * [Relationship] between [Element]. All of the operations
+ * defined on the index are asynchronous, and results, when there are any, are provided through a
+ * callback.
+ *
+ * Despite being asynchronous, the results of the operations are guaranteed to be consistent with
+ * the expectation that operations are performed in the order in which they are requested.
+ * Modification operations are executed before any read operation. There is no guarantee about the
+ * order in which the callbacks for read operations will be invoked.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class Index {
+  /**
+   * Asynchronously invoke the given callback with an array containing all of the locations of the
+   * elements that have the given relationship with the given element. For example, if the element
+   * represents a method and the relationship is the is-referenced-by relationship, then the
+   * locations that will be passed into the callback will be all of the places where the method is
+   * invoked.
+   *
+   * @param element the element that has the relationship with the locations to be returned
+   * @param relationship the relationship between the given element and the locations to be returned
+   * @param callback the callback that will be invoked when the locations are found
+   */
+  void getRelationships(Element element, Relationship relationship, RelationshipCallback callback);
+
+  /**
+   * Answer index statistics.
+   */
+  String get statistics;
+
+  /**
+   * Asynchronously process the given [HtmlUnit] in order to record the relationships.
+   *
+   * @param context the [AnalysisContext] in which [HtmlUnit] was resolved
+   * @param unit the [HtmlUnit] being indexed
+   */
+  void indexHtmlUnit(AnalysisContext context, ht.HtmlUnit unit);
+
+  /**
+   * Asynchronously process the given [CompilationUnit] in order to record the relationships.
+   *
+   * @param context the [AnalysisContext] in which [CompilationUnit] was resolved
+   * @param unit the [CompilationUnit] being indexed
+   */
+  void indexUnit(AnalysisContext context, CompilationUnit unit);
+
+  /**
+   * Asynchronously remove from the index all of the information associated with the given context.
+   *
+   * This method should be invoked when a context is disposed.
+   *
+   * @param context the [AnalysisContext] to remove
+   */
+  void removeContext(AnalysisContext context);
+
+  /**
+   * Asynchronously remove from the index all of the information associated with elements or
+   * locations in the given source. This includes relationships between an element in the given
+   * source and any other locations, relationships between any other elements and a location within
+   * the given source.
+   *
+   * This method should be invoked when a source is no longer part of the code base.
+   *
+   * @param context the [AnalysisContext] in which [Source] being removed
+   * @param source the [Source] being removed
+   */
+  void removeSource(AnalysisContext context, Source source);
+
+  /**
+   * Asynchronously remove from the index all of the information associated with elements or
+   * locations in the given sources. This includes relationships between an element in the given
+   * sources and any other locations, relationships between any other elements and a location within
+   * the given sources.
+   *
+   * This method should be invoked when multiple sources are no longer part of the code base.
+   *
+   * @param the [AnalysisContext] in which [Source]s being removed
+   * @param container the [SourceContainer] holding the sources being removed
+   */
+  void removeSources(AnalysisContext context, SourceContainer container);
+
+  /**
+   * Should be called in separate [Thread] to process request in this [Index]. Does not
+   * return until the [stop] method is called.
+   */
+  void run();
+
+  /**
+   * Should be called to stop process running [run], so stop processing requests.
+   */
+  void stop();
+}
+
+/**
+ * Container of information computed by the index - relationships between elements.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class IndexStore {
+  /**
+   * Notifies the index store that we are going to index the unit with the given element.
+   *
+   * If the unit is a part of a library, then all its locations are removed. If it is a defining
+   * compilation unit of a library, then index store also checks if some previously indexed parts of
+   * the library are not parts of the library anymore, and clears their information.
+   *
+   * @param the [AnalysisContext] in which unit being indexed
+   * @param unitElement the element of the unit being indexed
+   * @return `true` the given [AnalysisContext] is active, or `false` if it was
+   *         removed before, so no any unit may be indexed with it
+   */
+  bool aboutToIndex(AnalysisContext context, CompilationUnitElement unitElement);
+
+  /**
+   * Notifies the index store that we are going to index the given [Source].
+   *
+   * This method should be used only for a [Source] that cannot be a part of multiple
+   * libraries. Otherwise [aboutToIndex] should be
+   * used.
+   *
+   * @param the [AnalysisContext] in which unit being indexed
+   * @param source the [Source] being indexed
+   * @return `true` the given [AnalysisContext] is active, or `false` if it was
+   *         removed before, so no any unit may be indexed with it
+   */
+  bool aboutToIndex2(AnalysisContext context, Source source);
+
+  /**
+   * Return the locations of the elements that have the given relationship with the given element.
+   * For example, if the element represents a method and the relationship is the is-referenced-by
+   * relationship, then the returned locations will be all of the places where the method is
+   * invoked.
+   *
+   * @param element the the element that has the relationship with the locations to be returned
+   * @param relationship the [Relationship] between the given element and the locations to be
+   *          returned
+   * @return the locations that have the given relationship with the given element
+   */
+  List<Location> getRelationships(Element element, Relationship relationship);
+
+  /**
+   * Answer index statistics.
+   */
+  String get statistics;
+
+  /**
+   * Record that the given element and location have the given relationship. For example, if the
+   * relationship is the is-referenced-by relationship, then the element would be the element being
+   * referenced and the location would be the point at which it is referenced. Each element can have
+   * the same relationship with multiple locations. In other words, if the following code were
+   * executed
+   *
+   * <pre>
+   *   recordRelationship(element, isReferencedBy, location1);
+   *   recordRelationship(element, isReferencedBy, location2);
+   * </pre>
+   *
+   * then both relationships would be maintained in the index and the result of executing
+   *
+   * <pre>
+   *   getRelationship(element, isReferencedBy);
+   * </pre>
+   *
+   * would be an array containing both <code>location1</code> and <code>location2</code>.
+   *
+   * @param element the element that is related to the location
+   * @param relationship the [Relationship] between the element and the location
+   * @param location the [Location] where relationship happens
+   */
+  void recordRelationship(Element element, Relationship relationship, Location location);
+
+  /**
+   * Remove from the index all of the information associated with [AnalysisContext].
+   *
+   * This method should be invoked when a context is disposed.
+   *
+   * @param the [AnalysisContext] being removed
+   */
+  void removeContext(AnalysisContext context);
+
+  /**
+   * Remove from the index all of the information associated with elements or locations in the given
+   * source. This includes relationships between an element in the given source and any other
+   * locations, relationships between any other elements and a location within the given source.
+   *
+   * This method should be invoked when a source is no longer part of the code base.
+   *
+   * @param the [AnalysisContext] in which [Source] being removed
+   * @param source the source being removed
+   */
+  void removeSource(AnalysisContext context, Source source);
+
+  /**
+   * Remove from the index all of the information associated with elements or locations in the given
+   * sources. This includes relationships between an element in the given sources and any other
+   * locations, relationships between any other elements and a location within the given sources.
+   *
+   * This method should be invoked when multiple sources are no longer part of the code base.
+   *
+   * @param the [AnalysisContext] in which [Source]s being removed
+   * @param container the [SourceContainer] holding the sources being removed
+   */
+  void removeSources(AnalysisContext context, SourceContainer container);
+}
+
+/**
+ * Implementation of [UniverseElement].
+ *
+ * @coverage dart.engine.index
+ */
+class UniverseElementImpl extends ElementImpl implements UniverseElement {
+  static UniverseElementImpl INSTANCE = new UniverseElementImpl();
+
+  UniverseElementImpl() : super.con2("--universe--", -1);
+
+  accept(ElementVisitor visitor) => null;
+
+  ElementKind get kind => ElementKind.UNIVERSE;
+}
+
+/**
+ * Visits resolved AST and adds relationships into [IndexStore].
+ *
+ * @coverage dart.engine.index
+ */
+class IndexContributor extends GeneralizingASTVisitor<Object> {
+  /**
+   * @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) {
+    IndexContributor_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 IndexContributor_ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
+    IndexContributor_ImportElementInfo info = new IndexContributor_ImportElementInfo();
+    ASTNode parent = prefixNode.parent;
+    CompilationUnit unit = prefixNode.getAncestor(CompilationUnit);
+    LibraryElement libraryElement = unit.element.library;
+    Element usedElement = null;
+    if (parent is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = parent;
+      usedElement = prefixed.staticElement;
+      info._periodEnd = prefixed.period.end;
+    }
+    if (parent is MethodInvocation) {
+      MethodInvocation invocation = parent;
+      usedElement = invocation.methodName.staticElement;
+      info._periodEnd = invocation.period.end;
+    }
+    if (usedElement == null) {
+      return null;
+    }
+    String prefix = prefixNode.name;
+    Map<ImportElement, Set<Element>> importElementsMap = {};
+    info._element = getImportElement2(libraryElement, prefix, usedElement, importElementsMap);
+    if (info._element == null) {
+      return null;
+    }
+    return info;
+  }
+
+  /**
+   * @return the [ImportElement] that declares given [PrefixElement] and imports library
+   *         with given "usedElement".
+   */
+  static ImportElement getImportElement2(LibraryElement libraryElement, String prefix, Element usedElement, Map<ImportElement, Set<Element>> importElementsMap) {
+    if (usedElement == null) {
+      return null;
+    }
+    if (usedElement.enclosingElement is! CompilationUnitElement) {
+      return null;
+    }
+    LibraryElement usedLibrary = usedElement.library;
+    List<ImportElement> candidates = null;
+    for (ImportElement importElement in libraryElement.imports) {
+      if (importElement.importedLibrary != usedLibrary) {
+        continue;
+      }
+      PrefixElement prefixElement = importElement.prefix;
+      if (prefix == null) {
+        if (prefixElement != null) {
+          continue;
+        }
+      } else {
+        if (prefixElement == null) {
+          continue;
+        }
+        if (prefix != prefixElement.name) {
+          continue;
+        }
+      }
+      if (importElement.combinators.length == 0) {
+        return importElement;
+      }
+      if (candidates == null) {
+        candidates = [];
+      }
+      candidates.add(importElement);
+    }
+    if (candidates == null) {
+      return null;
+    }
+    if (candidates.length == 1) {
+      return candidates[0];
+    }
+    for (ImportElement importElement in candidates) {
+      if (importElementsMap.containsKey(importElement)) {
+        continue;
+      }
+      Namespace namespace = new NamespaceBuilder().createImportNamespace(importElement);
+      Set<Element> elements = new Set();
+      importElementsMap[importElement] = elements;
+    }
+    for (MapEntry<ImportElement, Set<Element>> entry in getMapEntrySet(importElementsMap)) {
+      if (entry.getValue().contains(usedElement)) {
+        return entry.getKey();
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 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<Type2>.con1(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) {
+    if (element is! PropertyAccessorElement) {
+      return location;
+    }
+    PropertyAccessorElement accessor = element as PropertyAccessorElement;
+    if (!accessor.isSetter) {
+      return location;
+    }
+    if (!accessor.isSynthetic) {
+      return location;
+    }
+    ASTNode parent;
+    {
+      ASTNode node = identifier;
+      parent = node.parent;
+      if (parent is PropertyAccess) {
+        PropertyAccess propertyAccess = parent as PropertyAccess;
+        if (identical(propertyAccess.propertyName, node)) {
+          node = propertyAccess;
+          parent = propertyAccess.parent;
+        }
+      }
+      if (parent is PrefixedIdentifier) {
+        PrefixedIdentifier prefixedIdentifier = parent as PrefixedIdentifier;
+        if (identical(prefixedIdentifier.identifier, node)) {
+          node = prefixedIdentifier;
+          parent = prefixedIdentifier.parent;
+        }
+      }
+    }
+    if (parent is AssignmentExpression) {
+      AssignmentExpression assignment = parent as AssignmentExpression;
+      Expression rhs = assignment.rightHandSide;
+      location = getLocationWithExpressionType(location, rhs);
+    }
+    return location;
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @return `true` if given [SimpleIdentifier] is "name" part of prefixed identifier or
+   *         method invocation.
+   */
+  static bool isQualified(SimpleIdentifier node) {
+    ASTNode parent = node.parent;
+    if (parent is PrefixedIdentifier) {
+      return identical(parent.identifier, node);
+    }
+    if (parent is PropertyAccess) {
+      return identical(parent.propertyName, node);
+    }
+    if (parent is MethodInvocation) {
+      MethodInvocation invocation = parent;
+      return invocation.realTarget != null && identical(invocation.methodName, node);
+    }
+    return false;
+  }
+
+  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(IndexStore store) {
+    this._store = 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;
+  }
+
+  Object visitAssignmentExpression(AssignmentExpression node) {
+    recordOperatorReference(node.operator, node.bestElement);
+    return super.visitAssignmentExpression(node);
+  }
+
+  Object visitBinaryExpression(BinaryExpression node) {
+    recordOperatorReference(node.operator, node.bestElement);
+    return super.visitBinaryExpression(node);
+  }
+
+  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, createLocation3(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();
+    }
+  }
+
+  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();
+    }
+  }
+
+  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;
+  }
+
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ConstructorElement element = node.element;
+    {
+      Location location;
+      if (node.name != null) {
+        int start = node.period.offset;
+        int end = node.name.end;
+        location = createLocation3(start, end - start);
+      } else {
+        int start = node.returnType.end;
+        location = createLocation3(start, 0);
+      }
+      recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
+    }
+    enterScope(element);
+    try {
+      return super.visitConstructorDeclaration(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitConstructorName(ConstructorName node) {
+    ConstructorElement element = node.staticElement;
+    Location location;
+    if (node.name != null) {
+      int start = node.period.offset;
+      int end = node.name.end;
+      location = createLocation3(start, end - start);
+    } else {
+      int start = node.type.end;
+      location = createLocation3(start, 0);
+    }
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitConstructorName(node);
+  }
+
+  Object visitExportDirective(ExportDirective node) {
+    ExportElement element = node.element as ExportElement;
+    if (element != null) {
+      LibraryElement expLibrary = element.exportedLibrary;
+      recordLibraryReference(node, expLibrary);
+    }
+    return super.visitExportDirective(node);
+  }
+
+  Object visitFormalParameter(FormalParameter node) {
+    ParameterElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitFormalParameter(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    Element element = node.element;
+    recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION);
+    enterScope(element);
+    try {
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    Element element = node.element;
+    recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION_TYPE);
+    return super.visitFunctionTypeAlias(node);
+  }
+
+  Object visitImportDirective(ImportDirective node) {
+    ImportElement element = node.element;
+    if (element != null) {
+      LibraryElement impLibrary = element.importedLibrary;
+      recordLibraryReference(node, impLibrary);
+    }
+    return super.visitImportDirective(node);
+  }
+
+  Object visitIndexExpression(IndexExpression node) {
+    MethodElement element = node.bestElement;
+    if (element is MethodElement) {
+      Token operator = node.leftBracket;
+      Location location = createLocation4(operator);
+      recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED, location);
+    }
+    return super.visitIndexExpression(node);
+  }
+
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitMethodDeclaration(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitMethodInvocation(MethodInvocation node) {
+    SimpleIdentifier name = node.methodName;
+    Element element = name.bestElement;
+    if (element is MethodElement) {
+      Location location = createLocation2(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) {
+      Location location = createLocation2(name);
+      recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
+    }
+    recordImportElementReferenceWithoutPrefix(name);
+    return super.visitMethodInvocation(node);
+  }
+
+  Object visitPartDirective(PartDirective node) {
+    Element element = node.element;
+    Location location = createLocation2(node.uri);
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitPartDirective(node);
+  }
+
+  Object visitPartOfDirective(PartOfDirective node) {
+    Location location = createLocation2(node.libraryName);
+    recordRelationship(node.element, IndexConstants.IS_REFERENCED_BY, location);
+    return null;
+  }
+
+  Object visitPostfixExpression(PostfixExpression node) {
+    recordOperatorReference(node.operator, node.bestElement);
+    return super.visitPostfixExpression(node);
+  }
+
+  Object visitPrefixExpression(PrefixExpression node) {
+    recordOperatorReference(node.operator, node.bestElement);
+    return super.visitPrefixExpression(node);
+  }
+
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    Element nameElement = new NameElementImpl(node.name);
+    Location location = createLocation2(node);
+    if (node.inDeclarationContext()) {
+      recordRelationship(nameElement, IndexConstants.IS_DEFINED_BY, location);
+      return null;
+    }
+    Element element = node.bestElement;
+    recordQualifiedMemberReference(node, element, nameElement, location);
+    if (isAlreadyHandledName(node)) {
+      return null;
+    }
+    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 (isQualified(node)) {
+        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);
+  }
+
+  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 = createLocation3(start, end - start);
+    } else {
+      int start = node.keyword.end;
+      location = createLocation3(start, 0);
+    }
+    recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
+    return super.visitSuperConstructorInvocation(node);
+  }
+
+  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);
+  }
+
+  Object visitTypeParameter(TypeParameter node) {
+    TypeParameterElement element = node.element;
+    enterScope(element);
+    try {
+      return super.visitTypeParameter(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    VariableElement element = node.element;
+    {
+      SimpleIdentifier name = node.name;
+      Location location = createLocation2(name);
+      location = getLocationWithExpressionType(location, node.initializer);
+      recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
+    }
+    enterScope(element);
+    try {
+      return super.visitVariableDeclaration(node);
+    } finally {
+      exitScope();
+    }
+  }
+
+  Object visitVariableDeclarationList(VariableDeclarationList node) {
+    NodeList<VariableDeclaration> variables = node.variables;
+    if (variables != null) {
+      {
+        TypeName type = node.type;
+        if (type != null) {
+          for (VariableDeclaration variableDeclaration in variables) {
+            enterScope(variableDeclaration.element);
+            try {
+              type.accept(this);
+            } finally {
+              exitScope();
+            }
+            break;
+          }
+        }
+      }
+      variables.accept(this);
+    }
+    return null;
+  }
+
+  /**
+   * @return the [Location] representing location of the [ASTNode].
+   */
+  Location createLocation2(ASTNode node) => createLocation3(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 createLocation3(int offset, int length) {
+    Element element = peekElement();
+    return new Location(element, offset, length);
+  }
+
+  /**
+   * @return the [Location] representing location of the [Token].
+   */
+  Location createLocation4(Token token) => createLocation3(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) {
+      Element element = node.staticElement;
+      if (element is MethodElement || element is FunctionElement) {
+        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] reference if given [SimpleIdentifier] references some
+   * top-level element and not qualified with import prefix.
+   */
+  void recordImportElementReferenceWithoutPrefix(SimpleIdentifier node) {
+    if (isIdentifierInPrefixedIdentifier(node)) {
+      return;
+    }
+    Element element = node.staticElement;
+    ImportElement importElement = getImportElement2(_libraryElement, null, element, _importElementsMap);
+    if (importElement != null) {
+      Location location = createLocation3(node.offset, 0);
+      recordRelationship(importElement, IndexConstants.IS_REFERENCED_BY, location);
+    }
+  }
+
+  /**
+   * Records [ImportElement] that declares given prefix and imports library with element used
+   * with given prefix node.
+   */
+  void recordImportElementReferenceWithPrefix(SimpleIdentifier prefixNode) {
+    IndexContributor_ImportElementInfo info = getImportElementInfo(prefixNode);
+    if (info != null) {
+      int offset = prefixNode.offset;
+      int length = info._periodEnd - offset;
+      Location location = createLocation3(offset, length);
+      recordRelationship(info._element, 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 = createLocation2(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) {
+    Location location = createLocation4(operator);
+    {
+      String name = operator.lexeme;
+      if (name == "++") {
+        name = "+";
+      }
+      if (name == "--") {
+        name = "-";
+      }
+      if (name.endsWith("=") && name != "==") {
+        name = name.substring(0, name.length - 1);
+      }
+      Element nameElement = new NameElementImpl(name);
+      Relationship relationship = element != null ? IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED : IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
+      recordRelationship(nameElement, relationship, location);
+    }
+    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 (isQualified(node)) {
+      Relationship relationship = element != null ? IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED : IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED;
+      recordRelationship(nameElement, relationship, location);
+    }
+  }
+
+  /**
+   * 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);
+    }
+  }
+
+  /**
+   * 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, createLocation2(superNode));
+      }
+    }
+  }
+}
+
+/**
+ * Information about [ImportElement] and place where it is referenced using
+ * [PrefixElement].
+ */
+class IndexContributor_ImportElementInfo {
+  ImportElement _element;
+
+  int _periodEnd = 0;
+}
+
+/**
+ * Factory for [Index] and [IndexStore].
+ *
+ * @coverage dart.engine.index
+ */
+class IndexFactory {
+  /**
+   * @return the new instance of [Index] which uses given [IndexStore].
+   */
+  static Index newIndex(IndexStore store) {
+    OperationQueue queue = new OperationQueue();
+    OperationProcessor processor = new OperationProcessor(queue);
+    return new IndexImpl(store, queue, processor);
+  }
+
+  /**
+   * @return the new instance of [MemoryIndexStore].
+   */
+  static MemoryIndexStore newMemoryIndexStore() => new MemoryIndexStoreImpl();
+}
+
+/**
+ * Instances of the [OperationQueue] represent a queue of operations against the index that
+ * are waiting to be performed.
+ *
+ * @coverage dart.engine.index
+ */
+class OperationQueue {
+  /**
+   * The non-query operations that are waiting to be performed.
+   */
+  Queue<IndexOperation> _nonQueryOperations = new Queue();
+
+  /**
+   * The query operations that are waiting to be performed.
+   */
+  Queue<IndexOperation> _queryOperations = new Queue();
+
+  /**
+   * `true` if query operations should be returned by [dequeue] or {code false}
+   * if not.
+   */
+  bool _processQueries = true;
+
+  /**
+   * If this queue is not empty, then remove the next operation from the head of this queue and
+   * return it. If this queue is empty (see [setProcessQueries], then the behavior
+   * of this method depends on the value of the argument. If the argument is less than or equal to
+   * zero (<code>0</code>), then `null` will be returned immediately. If the argument is
+   * greater than zero, then this method will wait until at least one operation has been added to
+   * this queue or until the given amount of time has passed. If, at the end of that time, this
+   * queue is empty, then `null` will be returned. If this queue is not empty, then the first
+   * operation will be removed and returned.
+   *
+   * Note that `null` can be returned, even if a positive timeout is given.
+   *
+   * Note too that this method's timeout is not treated the same way as the timeout value used for
+   * [Object#wait]. In particular, it is not possible to cause this method to wait for
+   * an indefinite period of time.
+   *
+   * @param timeout the maximum number of milliseconds to wait for an operation to be available
+   *          before giving up and returning `null`
+   * @return the operation that was removed from the queue
+   * @throws InterruptedException if the thread on which this method is running was interrupted
+   *           while it was waiting for an operation to be added to the queue
+   */
+  IndexOperation dequeue(int timeout) {
+    {
+      if (_nonQueryOperations.isEmpty && (!_processQueries || _queryOperations.isEmpty)) {
+        if (timeout <= 0) {
+          return null;
+        }
+        waitForOperationAvailable(timeout);
+      }
+      if (!_nonQueryOperations.isEmpty) {
+        return _nonQueryOperations.removeFirst();
+      }
+      if (_processQueries && !_queryOperations.isEmpty) {
+        return _queryOperations.removeFirst();
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Add the given operation to the tail of this queue.
+   *
+   * @param operation the operation to be added to the queue
+   */
+  void enqueue(IndexOperation operation) {
+    {
+      if (operation is RemoveSourceOperation) {
+        Source source = operation.source;
+        removeForSource(source, _nonQueryOperations);
+        removeForSource(source, _queryOperations);
+      }
+      if (operation.isQuery) {
+        _queryOperations.add(operation);
+      } else {
+        _nonQueryOperations.add(operation);
+      }
+      notifyOperationAvailable();
+    }
+  }
+
+  /**
+   * Return a list containing all of the operations that are currently on the queue. Modifying this
+   * list will not affect the state of the queue.
+   *
+   * @return all of the operations that are currently on the queue
+   */
+  List<IndexOperation> get operations {
+    List<IndexOperation> operations = [];
+    {
+      operations.addAll(_nonQueryOperations);
+      operations.addAll(_queryOperations);
+    }
+    return operations;
+  }
+
+  /**
+   * Set whether the receiver's [dequeue] method should return query operations.
+   *
+   * @param processQueries `true` if the receiver's [dequeue] method should
+   *          return query operations or `false` if query operations should be queued but not
+   *          returned by the receiver's [dequeue] method until this method is called
+   *          with a value of `true`.
+   */
+  void set processQueries(bool processQueries) {
+    {
+      if (this._processQueries != processQueries) {
+        this._processQueries = processQueries;
+        if (processQueries && !_queryOperations.isEmpty) {
+          notifyOperationAvailable();
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the number of operations on the queue.
+   *
+   * @return the number of operations on the queue
+   */
+  int size() {
+    {
+      return _nonQueryOperations.length + _queryOperations.length;
+    }
+  }
+
+  void notifyOperationAvailable() {
+  }
+
+  /**
+   * Removes operations that should be removed when given [Source] is removed.
+   */
+  void removeForSource(Source source, Queue<IndexOperation> operations) {
+    operations.removeWhere((_) => _.removeWhenSourceRemoved(source));
+  }
+
+  void waitForOperationAvailable(int timeout) {
+  }
+}
+
+/**
+ * Special [Element] which is used to index references to the name without specifying concrete
+ * kind of this name - field, method or something else.
+ *
+ * @coverage dart.engine.index
+ */
+class NameElementImpl extends ElementImpl {
+  NameElementImpl(String name) : super.con2("name:${name}", -1);
+
+  accept(ElementVisitor visitor) => null;
+
+  ElementKind get kind => ElementKind.NAME;
+}
+
+/**
+ * Visits resolved [CompilationUnit] and adds Angular specific relationships into
+ * [IndexStore].
+ *
+ * @coverage dart.engine.index
+ */
+class AngularDartIndexContributor extends GeneralizingASTVisitor<Object> {
+  IndexStore _store;
+
+  AngularDartIndexContributor(IndexStore store) {
+    this._store = store;
+  }
+
+  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 AngularDirectiveElement) {
+          AngularDirectiveElement directive = object;
+          indexDirective(directive);
+        }
+      }
+    }
+    return null;
+  }
+
+  Object visitCompilationUnitMember(CompilationUnitMember node) => null;
+
+  void indexComponent(AngularComponentElement component) {
+    indexProperties(component.properties);
+  }
+
+  void indexDirective(AngularDirectiveElement directive) {
+    indexProperties(directive.properties);
+  }
+
+  void indexProperties(List<AngularPropertyElement> properties) {
+    for (AngularPropertyElement property in properties) {
+      FieldElement field = property.field;
+      if (field != null) {
+        int offset = property.fieldNameOffset;
+        int length = field.name.length;
+        Location location = new Location(property, offset, length);
+        _store.recordRelationship(field, IndexConstants.IS_REFERENCED_BY, location);
+      }
+    }
+  }
+}
+
+/**
+ * Instances of the [RemoveContextOperation] implement an operation that removes from the
+ * index any data based on the specified [AnalysisContext].
+ *
+ * @coverage dart.engine.index
+ */
+class RemoveContextOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  IndexStore _indexStore;
+
+  /**
+   * The context being removed.
+   */
+  final AnalysisContext context;
+
+  /**
+   * Initialize a newly created operation that will remove the specified resource.
+   *
+   * @param indexStore the index store against which this operation is being run
+   * @param context the [AnalysisContext] to remove
+   */
+  RemoveContextOperation(IndexStore indexStore, this.context) {
+    this._indexStore = indexStore;
+  }
+
+  bool get isQuery => false;
+
+  void performOperation() {
+    {
+      _indexStore.removeContext(context);
+    }
+  }
+
+  bool removeWhenSourceRemoved(Source source) => false;
+
+  String toString() => "RemoveContext(${context})";
+}
+
+/**
+ * Instances of the [IndexHtmlUnitOperation] implement an operation that adds data to the
+ * index based on the resolved [HtmlUnit].
+ *
+ * @coverage dart.engine.index
+ */
+class IndexHtmlUnitOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  IndexStore _indexStore;
+
+  /**
+   * The context in which [HtmlUnit] was resolved.
+   */
+  AnalysisContext _context;
+
+  /**
+   * The [HtmlUnit] being indexed.
+   */
+  final ht.HtmlUnit unit;
+
+  /**
+   * The element of the [HtmlUnit] being indexed.
+   */
+  HtmlElement _htmlElement;
+
+  /**
+   * The source being indexed.
+   */
+  Source _source;
+
+  /**
+   * Initialize a newly created operation that will index the specified [HtmlUnit].
+   *
+   * @param indexStore the index store against which this operation is being run
+   * @param context the context in which [HtmlUnit] was resolved
+   * @param unit the fully resolved [HtmlUnit]
+   */
+  IndexHtmlUnitOperation(IndexStore indexStore, AnalysisContext context, this.unit) {
+    this._indexStore = indexStore;
+    this._context = context;
+    this._htmlElement = unit.element;
+    this._source = _htmlElement.source;
+  }
+
+  /**
+   * @return the [Source] to be indexed.
+   */
+  Source get source => _source;
+
+  bool get isQuery => false;
+
+  void performOperation() {
+    {
+      try {
+        bool mayIndex = _indexStore.aboutToIndex2(_context, _source);
+        if (!mayIndex) {
+          return;
+        }
+        AngularHtmlIndexContributor contributor = new AngularHtmlIndexContributor(_indexStore);
+        unit.accept(contributor);
+      } catch (exception) {
+        AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
+      }
+    }
+  }
+
+  bool removeWhenSourceRemoved(Source source) => this._source == source;
+
+  String toString() => "IndexHtmlUnitOperation(${_source.fullName})";
+}
+
+/**
+ * Instances of the class <code>Location</code> represent a location related to an element. The
+ * location is expressed as an offset and length, but the offset is relative to the resource
+ * containing the element rather than the start of the element within that resource.
+ *
+ * @coverage dart.engine.index
+ */
+class Location {
+  /**
+   * An empty array of locations.
+   */
+  static List<Location> EMPTY_ARRAY = new List<Location>(0);
+
+  /**
+   * The element containing this location.
+   */
+  final Element element;
+
+  /**
+   * The offset of this location within the resource containing the element.
+   */
+  final int offset;
+
+  /**
+   * The length of this location.
+   */
+  final int length;
+
+  /**
+   * Internal field used to hold a key that is referenced at this location.
+   */
+  Object internalKey;
+
+  /**
+   * Initialize a newly create location to be relative to the given element at the given offset with
+   * the given length.
+   *
+   * @param element the [Element] containing this location
+   * @param offset the offset of this location within the resource containing the element
+   * @param length the length of this location
+   */
+  Location(this.element, this.offset, this.length) {
+    if (element == null) {
+      throw new IllegalArgumentException("element location cannot be null");
+    }
+  }
+
+  Location clone() => new Location(element, offset, length);
+
+  String toString() => "[${offset} - ${(offset + length)}) in ${element}";
+}
+
+/**
+ * [IndexStore] which keeps all information in memory, but can write it to stream and read
+ * later.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class MemoryIndexStore implements IndexStore {
+}
+
+/**
+ * Instances of the [GetRelationshipsOperation] implement an operation used to access the
+ * locations that have a specified relationship with a specified element.
+ *
+ * @coverage dart.engine.index
+ */
+class GetRelationshipsOperation implements IndexOperation {
+  IndexStore _indexStore;
+
+  final Element element;
+
+  final Relationship relationship;
+
+  final RelationshipCallback callback;
+
+  /**
+   * Initialize a newly created operation that will access the locations that have a specified
+   * relationship with a specified element.
+   */
+  GetRelationshipsOperation(IndexStore indexStore, this.element, this.relationship, this.callback) {
+    this._indexStore = indexStore;
+  }
+
+  bool get isQuery => true;
+
+  void performOperation() {
+    List<Location> locations;
+    {
+      locations = _indexStore.getRelationships(element, relationship);
+    }
+    callback.hasRelationships(element, relationship, locations);
+  }
+
+  bool removeWhenSourceRemoved(Source source) => false;
+
+  String toString() => "GetRelationships(${element}, ${relationship})";
+}
+
+/**
+ * [Location] with attached data.
+ */
+class LocationWithData<D> extends Location {
+  final D data;
+
+  LocationWithData.con1(Location location, this.data) : super(location.element, location.offset, location.length);
+
+  LocationWithData.con2(Element element, int offset, int length, this.data) : super(element, offset, length);
+
+  Location clone() => new LocationWithData<D>.con2(element, offset, length, data);
+}
+
+/**
+ * The interface <code>RelationshipCallback</code> defines the behavior of objects that are invoked
+ * with the results of a query about a given relationship.
+ *
+ * @coverage dart.engine.index
+ */
+abstract class RelationshipCallback {
+  /**
+   * This method is invoked when the locations that have a specified relationship with a specified
+   * element are available. For example, if the element is a field and the relationship is the
+   * is-referenced-by relationship, then this method will be invoked with each location at which the
+   * field is referenced.
+   *
+   * @param element the [Element] that has the relationship with the locations
+   * @param relationship the relationship between the given element and the locations
+   * @param locations the locations that were found
+   */
+  void hasRelationships(Element element, Relationship relationship, List<Location> locations);
+}