New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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;
@@ skipping 156 matching lines @@
     }
     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);
 }
 
 /**
+ * Instances of the [ClearOperation] implement an operation that removes all of the
+ * information from the index.
+ */
+class ClearOperation implements IndexOperation {
+  /**
+   * The index store against which this operation is being run.
+   */
+  final IndexStore _indexStore;
+
+  ClearOperation(this._indexStore);
+
+  @override
+  bool get isQuery => false;
+
+  @override
+  void performOperation() {
+    _indexStore.clear();
+  }
+
+  @override
+  bool removeWhenSourceRemoved(Source source) => false;
+
+  @override
+  String toString() => "ClearOperation()";
+}
+
+/**
  * 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);
 
@@ skipping 71 matching lines @@
  * 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.
  */
 abstract class Index {
   /**
+   * Asynchronously remove from the index all of the information.
+   */
+  void clear();
+
+  /**
    * 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
    */
@@ skipping 1278 matching lines @@
    * Notifies the index store that we are going to index the given [HtmlElement].
    *
    * @param the [AnalysisContext] in which unit being indexed
    * @param htmlElement the [HtmlElement] 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 aboutToIndexHtml(AnalysisContext context, HtmlElement htmlElement);
 
   /**
+   * Removes all of the information.
+   */
+  void clear();
+
+  /**
    * 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
    */
@@ skipping 367 matching lines @@
         }
       }
     }
     // remember libraries in which unit is used
     _recordUnitInLibrary(context, null, source);
     // OK, we can index
     return true;
   }
 
   @override
+  void clear() {
+    _canonicalKeys.clear();
+    _keyToLocations.clear();
+    _contextToSourceToKeys.clear();
+    _contextToSourceToLocations.clear();
+    _contextToLibraryToUnits.clear();
+    _contextToUnitToLibraries.clear();
+  }
+
+  @override
   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;
   }
 
   @override
@@ skipping 572 matching lines @@
   static UniverseElementImpl INSTANCE = new UniverseElementImpl();
 
   UniverseElementImpl() : super("--universe--", -1);
 
   @override
   accept(ElementVisitor visitor) => null;
 
   @override
   ElementKind get kind => ElementKind.UNIVERSE;
 }