Improve used name relations and fields indexing.

pkg/analysis_server/lib/src/services/search/search_engine_internal2.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.
 
 library services.src.search.search_engine2;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/index2/index2.dart';
@@ skipping 25 matching lines @@
 
   @override
   Future<List<SearchMatch>> searchMemberDeclarations(String pattern) {
     return _searchDefinedNames(pattern, IndexNameKind.classMember);
   }
 
   @override
   Future<List<SearchMatch>> searchMemberReferences(String name) async {
     List<Location> locations = await _index.getUnresolvedMemberReferences(name);
     return locations.map((location) {
-      return _newMatchForLocation(location, MatchKind.REFERENCE);
+      return _newMatchForLocation(location, null);
     }).toList();
   }
 
   @override
   Future<List<SearchMatch>> searchReferences(Element element) {
     ElementKind kind = element.kind;
     if (kind == ElementKind.CLASS ||
         kind == ElementKind.COMPILATION_UNIT ||
         kind == ElementKind.CONSTRUCTOR ||
         kind == ElementKind.FUNCTION_TYPE_ALIAS ||
@@ skipping 45 matching lines @@
 
   _addMatches(List<SearchMatch> matches, Element element,
       IndexRelationKind relationKind, MatchKind kind) async {
     List<Location> locations = await _index.getRelations(element, relationKind);
     for (Location location in locations) {
       SearchMatch match = _newMatchForLocation(location, kind);
       matches.add(match);
     }
   }
 
-  SearchMatch _newMatchForLocation(Location location, MatchKind kind) =>
-      new SearchMatch(
-          location.context,
-          location.libraryUri,
-          location.unitUri,
-          kind,
-          new SourceRange(location.offset, location.length),
-          true,
-          location.isQualified);
+  SearchMatch _newMatchForLocation(Location location, MatchKind kind) {
+    if (kind == null) {
+      IndexRelationKind relationKind = location.kind;
+      if (relationKind == IndexRelationKind.IS_INVOKED_BY) {
+        kind = MatchKind.INVOCATION;
+      } else if (relationKind == IndexRelationKind.IS_REFERENCED_BY) {
+        kind = MatchKind.REFERENCE;
+      } else if (relationKind == IndexRelationKind.IS_READ_BY) {
+        kind = MatchKind.READ;
+      } else if (relationKind == IndexRelationKind.IS_READ_WRITTEN_BY) {
+        kind = MatchKind.READ_WRITE;
+      } else if (relationKind == IndexRelationKind.IS_WRITTEN_BY) {
+        kind = MatchKind.WRITE;
+      } else {
+        throw new ArgumentError('Unsupported relation kind $relationKind');
+      }
+    }
+    return new SearchMatch(
+        location.context,
+        location.libraryUri,
+        location.unitUri,
+        kind,
+        new SourceRange(location.offset, location.length),
+        location.isResolved,
+        location.isQualified);
+  }
 
   Future<List<SearchMatch>> _searchDefinedNames(
       String pattern, IndexNameKind nameKind) async {
     RegExp regExp = new RegExp(pattern);
     List<Location> locations = await _index.getDefinedNames(regExp, nameKind);
     return locations.map((location) {
       return _newMatchForLocation(location, MatchKind.DECLARATION);
     }).toList();
   }
 
   Future<List<SearchMatch>> _searchReferences(Element element) async {
     List<SearchMatch> matches = <SearchMatch>[];
     await _addMatches(matches, element, IndexRelationKind.IS_REFERENCED_BY,
         MatchKind.REFERENCE);
     return matches;
   }
 
   Future<List<SearchMatch>> _searchReferences_Field(
       PropertyInducingElement field) async {
     List<SearchMatch> matches = <SearchMatch>[];
     PropertyAccessorElement getter = field.getter;
     PropertyAccessorElement setter = field.setter;
     // field itself
     if (!field.isSynthetic) {
+      await _addMatches(
+          matches, field, IndexRelationKind.IS_WRITTEN_BY, MatchKind.WRITE);
       await _addMatches(matches, field, IndexRelationKind.IS_REFERENCED_BY,
           MatchKind.REFERENCE);
     }
     // getter
     if (getter != null) {
       await _addMatches(
           matches, getter, IndexRelationKind.IS_REFERENCED_BY, MatchKind.READ);
       await _addMatches(matches, getter, IndexRelationKind.IS_INVOKED_BY,
           MatchKind.INVOCATION);
     }
@@ skipping 227 matching lines @@
       _addMatch(node, kind);
     }
   }
 
   void _addMatch(AstNode node, MatchKind kind) {
     bool isQualified = node is SimpleIdentifier && node.isQualified;
     matches.add(new SearchMatch(context, libraryUri, unitUri, kind,
         rangeNode(node), true, isQualified));
   }
 }