Separate index objects for each analysis context.

pkg/analysis_server/lib/src/services/index2/index2.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/index_unit.dart';
 import 'package:collection/collection.dart';
 
 /**
  * Return a new [Index2] instance that keeps information in memory.
  */
 Index2 createMemoryIndex2() {
-  _MemoryPackageIndexStore store = new _MemoryPackageIndexStore();
-  return new Index2(store);
+  return new Index2._();
 }
 
 /**
  * Return the index of the first occurrence of the [value] in the [sortedList],
  * or `-1` if the [value] is not in the list.
  */
 int _findFirstOccurrence(List<int> sortedList, int value) {
   // Find an occurrence.
   int i = binarySearch(sortedList, value);
   if (i == -1) {
     return -1;
   }
   // Find the first occurrence.
   while (i > 0 && sortedList[i - 1] == value) {
     i--;
   }
   return i;
 }
 
 /**
  * Interface for storing and requesting relations.
  */
 class Index2 {
-  final PackageIndexStore _store;
+  final Map<AnalysisContext, _ContextIndex> _contextIndexMap =
+      <AnalysisContext, _ContextIndex>{};
 
-  Index2(this._store);
+  Index2._();
 
   /**
    * Complete with a list of locations where elements of the given [kind] with
    * names satisfying the given [regExp] are defined.
    */
-  Future<List<Location>> getDefinedNames(
-      RegExp regExp, IndexNameKind kind) async {
-    List<Location> locations = <Location>[];
-    Iterable<PackageIndexId> ids = await _store.getIds();
-    for (PackageIndexId id in ids) {
-      PackageIndex index = await _store.getIndex(id);
-      _PackageIndexRequester requester = new _PackageIndexRequester(index);
-      List<Location> packageLocations = requester.getDefinedNames(regExp, kind);
-      locations.addAll(packageLocations);
-    }
-    return locations;
+  Future<List<Location>> getDefinedNames(RegExp regExp, IndexNameKind kind) {
+    return _mergeLocations((_ContextIndex index) {
+      return index.getDefinedNames(regExp, kind);
+    });
   }
 
   /**
    * Complete with a list of locations where the given [element] has relation
    * of the given [kind].
    */
-  Future<List<Location>> getRelations(
-      Element element, IndexRelationKind kind) async {
-    List<Location> locations = <Location>[];
-    Iterable<PackageIndexId> ids = await _store.getIds();
-    for (PackageIndexId id in ids) {
-      PackageIndex index = await _store.getIndex(id);
-      _PackageIndexRequester requester = new _PackageIndexRequester(index);
-      List<Location> packageLocations = requester.getRelations(element, kind);
-      locations.addAll(packageLocations);
-    }
-    return locations;
+  Future<List<Location>> getRelations(Element element, IndexRelationKind kind) {
+    return _mergeLocations((_ContextIndex index) {
+      return index.getRelations(element, kind);
+    });
   }
 
   /**
    * Complete with a list of locations where a class members with the given
    * [name] is referenced with a qualifier, but is not resolved.
    */
-  Future<List<Location>> getUnresolvedMemberReferences(String name) async {
-    List<Location> locations = <Location>[];
-    Iterable<PackageIndexId> ids = await _store.getIds();
-    for (PackageIndexId id in ids) {
-      PackageIndex index = await _store.getIndex(id);
-      _PackageIndexRequester requester = new _PackageIndexRequester(index);
-      List<Location> packageLocations =
-          requester.getUnresolvedMemberReferences(name);
-      locations.addAll(packageLocations);
-    }
-    return locations;
+  Future<List<Location>> getUnresolvedMemberReferences(String name) {
+    return _mergeLocations((_ContextIndex index) {
+      return index.getUnresolvedMemberReferences(name);
+    });
   }
 
   /**
    * Index the given fully resolved [unit].
    */
   void indexUnit(CompilationUnit unit) {
-    PackageIndexAssembler assembler = new PackageIndexAssembler();
-    assembler.index(unit);
-    PackageIndexBuilder indexBuilder = assembler.assemble();
-    String unitLibraryUri = unit.element.library.source.uri.toString();
-    String unitUnitUri = unit.element.source.uri.toString();
-    _store.putIndex(unitLibraryUri, unitUnitUri, indexBuilder);
+    if (unit == null || unit.element == null) {
+      return;
+    }
+    AnalysisContext context = unit.element.context;
+    _getContextIndex(context).indexUnit(unit);
+  }
+
+  /**
+   * Remove all index information for the given [context].
+   */
+  void removeContext(AnalysisContext context) {
+    _contextIndexMap.remove(context);
+  }
+
+  /**
+   * Return the [_ContextIndex] instance for the given [context].
+   */
+  _ContextIndex _getContextIndex(AnalysisContext context) {
+    return _contextIndexMap.putIfAbsent(context, () {
+      return new _ContextIndex(context);
+    });
+  }
+
+  /**
+   * Complete with a list of all results returned by the [callback] for every
+   * context specific index.
+   */
+  Future<List<Location>> _mergeLocations(
+      Future<List<Location>> callback(_ContextIndex index)) async {
+    List<Location> locations = <Location>[];
+    for (_ContextIndex index in _contextIndexMap.values) {
+      List<Location> contextLocations = await callback(index);
+      locations.addAll(contextLocations);
+    }
+    return locations;
   }
 }
 
 /**
  * Information about location of a single relation in the index.
  *
  * The location is expressed as a library specific unit containing the index
  * relation, offset within this [Source] and  length.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class Location {
   /**
+   * The [AnalysisContext] containing this location.
+   */
+  final AnalysisContext context;
+
+  /**
    * The URI of the source of the library containing this location.
    */
   final String libraryUri;
 
   /**
    * The URI of the source of the unit containing this location.
    */
   final String unitUri;
 
   /**
    * The offset of this location within the [unitUri].
    */
   final int offset;
 
   /**
    * The length of this location.
    */
   final int length;
 
   /**
    * Is `true` if this location is qualified.
    */
   final bool isQualified;
 
-  Location(this.libraryUri, this.unitUri, this.offset, this.length,
-      this.isQualified);
+  Location(this.context, this.libraryUri, this.unitUri, this.offset,
+      this.length, this.isQualified);
 
   @override
   String toString() => 'Location{librarySourceUri: $libraryUri, '
       'unitSourceUri: $unitUri, offset: $offset, length: $length, '
       'isQualified: $isQualified}';
 }
 
 /**
  * Opaque identifier of a [PackageIndex].
  */
@@ skipping 14 matching lines @@
   Future<PackageIndex> getIndex(PackageIndexId id);
 
   /**
    * Put the given [indexBuilder] into the store.
    */
   void putIndex(String unitLibraryUri, String unitUnitUri,
       PackageIndexBuilder indexBuilder);
 }
 
 /**
- * A [PackageIndexId] for [_MemoryPackageIndexStore].
+ * The [AnalysisContext] specific index.
  */
-class _MemoryPackageIndexId implements PackageIndexId {
-  final String key;
-
-  _MemoryPackageIndexId(this.key);
-}
-
-/**
- * A [PackageIndexStore] that keeps objects in memory;
- */
-class _MemoryPackageIndexStore implements PackageIndexStore {
+class _ContextIndex {
+  final AnalysisContext context;
   final Map<String, PackageIndex> indexMap = <String, PackageIndex>{};
 
-  @override
-  Future<Iterable<PackageIndexId>> getIds() async {
-    return indexMap.keys.map((key) => new _MemoryPackageIndexId(key));
+  _ContextIndex(this.context);
+
+  /**
+   * Complete with a list of locations where elements of the given [kind] with
+   * names satisfying the given [regExp] are defined.
+   */
+  Future<List<Location>> getDefinedNames(
+      RegExp regExp, IndexNameKind kind) async {
+    return _mergeLocations((PackageIndex index) {
+      _PackageIndexRequester requester = new _PackageIndexRequester(index);
+      return requester.getDefinedNames(context, regExp, kind);
+    });
   }
 
-  @override
-  Future<PackageIndex> getIndex(PackageIndexId id) async {
-    return indexMap[(id as _MemoryPackageIndexId).key];
+  /**
+   * Complete with a list of locations where the given [element] has relation
+   * of the given [kind].
+   */
+  Future<List<Location>> getRelations(Element element, IndexRelationKind kind) {
+    return _mergeLocations((PackageIndex index) {
+      _PackageIndexRequester requester = new _PackageIndexRequester(index);
+      return requester.getRelations(context, element, kind);
+    });
   }
 
-  @override
-  putIndex(String unitLibraryUri, String unitUnitUri,
-      PackageIndexBuilder indexBuilder) {
+  /**
+   * Complete with a list of locations where a class members with the given
+   * [name] is referenced with a qualifier, but is not resolved.
+   */
+  Future<List<Location>> getUnresolvedMemberReferences(String name) async {
+    return _mergeLocations((PackageIndex index) {
+      _PackageIndexRequester requester = new _PackageIndexRequester(index);
+      return requester.getUnresolvedMemberReferences(context, name);
+    });
+  }
+
+  /**
+   * Index the given fully resolved [unit].
+   */
+  void indexUnit(CompilationUnit unit) {
+    // Index the unit.
+    PackageIndexAssembler assembler = new PackageIndexAssembler();
+    assembler.index(unit);
+    PackageIndexBuilder indexBuilder = assembler.assemble();
+    // Put the index into the map.
     List<int> indexBytes = indexBuilder.toBuffer();
     PackageIndex index = new PackageIndex.fromBuffer(indexBytes);
-    String key = '$unitLibraryUri;$unitUnitUri';
+    String key = _getUnitKeyForElement(unit.element);
     indexMap[key] = index;
   }
+
+  String _getUnitKeyForElement(CompilationUnitElement unitElement) {
+    Source librarySource = unitElement.library.source;
+    Source unitSource = unitElement.source;
+    return _getUnitKeyForSource(librarySource, unitSource);
+  }
+
+  String _getUnitKeyForSource(Source librarySource, Source unitSource) {
+    String unitLibraryUri = librarySource.uri.toString();
+    String unitUnitUri = unitSource.uri.toString();
+    return '$unitLibraryUri;$unitUnitUri';
+  }
+
+  Future<List<Location>> _mergeLocations(
+      List<Location> callback(PackageIndex index)) async {
+    List<Location> locations = <Location>[];
+    for (PackageIndex index in indexMap.values) {
+      List<Location> indexLocations = callback(index);
+      locations.addAll(indexLocations);
+    }
+    return locations;
+  }
 }
 
 /**
  * Helper for requesting information from a single [PackageIndex].
  */
 class _PackageIndexRequester {
   final PackageIndex index;
 
   _PackageIndexRequester(this.index);
 
@@ skipping 29 matching lines @@
         return elementId;
       }
     }
     return -1;
   }
 
   /**
    * Complete with a list of locations where elements of the given [kind] with
    * names satisfying the given [regExp] are defined.
    */
-  List<Location> getDefinedNames(RegExp regExp, IndexNameKind kind) {
+  List<Location> getDefinedNames(
+      AnalysisContext context, RegExp regExp, IndexNameKind kind) {
     List<Location> locations = <Location>[];
     for (UnitIndex unitIndex in index.units) {
       _UnitIndexRequester requester = new _UnitIndexRequester(this, unitIndex);
-      List<Location> unitLocations = requester.getDefinedNames(regExp, kind);
+      List<Location> unitLocations =
+          requester.getDefinedNames(context, regExp, kind);
       locations.addAll(unitLocations);
     }
     return locations;
   }
 
   /**
    * Complete with a list of locations where the given [element] has relation
    * of the given [kind].
    */
-  List<Location> getRelations(Element element, IndexRelationKind kind) {
+  List<Location> getRelations(
+      AnalysisContext context, Element element, IndexRelationKind kind) {
     int elementId = findElementId(element);
     if (elementId == -1) {
       return const <Location>[];
     }
     List<Location> locations = <Location>[];
     for (UnitIndex unitIndex in index.units) {
       _UnitIndexRequester requester = new _UnitIndexRequester(this, unitIndex);
-      List<Location> unitLocations = requester.getRelations(elementId, kind);
+      List<Location> unitLocations =
+          requester.getRelations(context, elementId, kind);
       locations.addAll(unitLocations);
     }
     return locations;
   }
 
   /**
    * Return the identifier of [str] in the [index] or `-1` if [str] is not used
    * in the [index].
    */
   int getStringId(String str) {
@@ skipping 37 matching lines @@
    */
   String getUnitUnitUri(int unit) {
     int id = index.unitUnitUris[unit];
     return index.strings[id];
   }
 
   /**
    * Complete with a list of locations where a class members with the given
    * [name] is referenced with a qualifier, but is not resolved.
    */
-  List<Location> getUnresolvedMemberReferences(String name) {
+  List<Location> getUnresolvedMemberReferences(
+      AnalysisContext context, String name) {
     List<Location> locations = <Location>[];
     for (UnitIndex unitIndex in index.units) {
       _UnitIndexRequester requester = new _UnitIndexRequester(this, unitIndex);
       List<Location> unitLocations =
-          requester.getUnresolvedMemberReferences(name);
+          requester.getUnresolvedMemberReferences(context, name);
       locations.addAll(unitLocations);
     }
     return locations;
   }
 
   /**
    * Return the identifier of the [uri] in the [index] or `-1` if the [uri] is
    * not used in the [index].
    */
   int getUriId(Uri uri) {
     String str = uri.toString();
     return getStringId(str);
   }
 }
 
 /**
  * Helper for requesting information from a single [UnitIndex].
  */
 class _UnitIndexRequester {
   final _PackageIndexRequester packageRequester;
   final UnitIndex unitIndex;
 
   _UnitIndexRequester(this.packageRequester, this.unitIndex);
 
   /**
    * Complete with a list of locations where elements of the given [kind] with
    * names satisfying the given [regExp] are defined.
    */
-  List<Location> getDefinedNames(RegExp regExp, IndexNameKind kind) {
+  List<Location> getDefinedNames(
+      AnalysisContext context, RegExp regExp, IndexNameKind kind) {
     List<Location> locations = <Location>[];
     String unitLibraryUri = null;
     String unitUnitUri = null;
     for (int i = 0; i < unitIndex.definedNames.length; i++) {
       if (unitIndex.definedNameKinds[i] == kind) {
         int nameIndex = unitIndex.definedNames[i];
         String name = packageRequester.index.strings[nameIndex];
         if (regExp.matchAsPrefix(name) != null) {
           unitLibraryUri ??= packageRequester.getUnitLibraryUri(unitIndex.unit);
           unitUnitUri ??= packageRequester.getUnitUnitUri(unitIndex.unit);
-          locations.add(new Location(unitLibraryUri, unitUnitUri,
+          locations.add(new Location(context, unitLibraryUri, unitUnitUri,
               unitIndex.definedNameOffsets[i], name.length, false));
         }
       }
     }
     return locations;
   }
 
   /**
    * Return a list of locations where an element with the given [elementId] has
    * relation of the given [kind].
    */
-  List<Location> getRelations(int elementId, IndexRelationKind kind) {
+  List<Location> getRelations(
+      AnalysisContext context, int elementId, IndexRelationKind kind) {
     // Find the first usage of the element.
     int i = _findFirstOccurrence(unitIndex.usedElements, elementId);
     if (i == -1) {
       return const <Location>[];
     }
     // Create locations for every usage of the element.
     List<Location> locations = <Location>[];
     String unitLibraryUri = null;
     String unitUnitUri = null;
     for (;
         i < unitIndex.usedElements.length &&
             unitIndex.usedElements[i] == elementId;
         i++) {
       if (unitIndex.usedElementKinds[i] == kind) {
         unitLibraryUri ??= packageRequester.getUnitLibraryUri(unitIndex.unit);
         unitUnitUri ??= packageRequester.getUnitUnitUri(unitIndex.unit);
         locations.add(new Location(
+            context,
             unitLibraryUri,
             unitUnitUri,
             unitIndex.usedElementOffsets[i],
             unitIndex.usedElementLengths[i],
             unitIndex.usedElementIsQualifiedFlags[i]));
       }
     }
     return locations;
   }
 
   /**
    * Complete with a list of locations where a class members with the given
    * [name] is referenced with a qualifier, but is not resolved.
    */
-  List<Location> getUnresolvedMemberReferences(String name) {
+  List<Location> getUnresolvedMemberReferences(
+      AnalysisContext context, String name) {
     // Find the name ID in the package index.
     int nameId = packageRequester.getStringId(name);
     if (nameId == -1) {
       return const <Location>[];
     }
     // Find the first usage of the name.
-    int i =_findFirstOccurrence(unitIndex.usedNames, nameId);
+    int i = _findFirstOccurrence(unitIndex.usedNames, nameId);
     if (i == -1) {
       return const <Location>[];
     }
     // Create locations for every usage of the name.
     List<Location> locations = <Location>[];
     String unitLibraryUri = null;
     String unitUnitUri = null;
-    for (; i < unitIndex.usedNames.length &&
-        unitIndex.usedNames[i] == nameId; i++) {
+    for (;
+        i < unitIndex.usedNames.length && unitIndex.usedNames[i] == nameId;
+        i++) {
       unitLibraryUri ??= packageRequester.getUnitLibraryUri(unitIndex.unit);
       unitUnitUri ??= packageRequester.getUnitUnitUri(unitIndex.unit);
-      locations.add(new Location(unitLibraryUri, unitUnitUri,
+      locations.add(new Location(context, unitLibraryUri, unitUnitUri,
           unitIndex.usedNameOffsets[i], name.length, true));
     }
     return locations;
   }
 }