Improve used name relations and fields indexing.

pkg/analyzer/test/src/summary/index_unit_test.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:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ skipping 638 matching lines @@
 main() {
   new A(); // 1
 }
 ''');
     ClassElement classA = findElement('A');
     ConstructorElement constA = classA.constructors[0];
     // A()
     assertThat(constA)..isReferencedAt('(); // 1', true, length: 0);
   }
 
-  void test_isReferencedBy_ConstructorFieldInitializer() {
-    _indexTestUnit('''
-class A {
-  int field;
-  A() : field = 5;
-}
-''');
-    FieldElement element = findElement('field');
-    assertThat(element).isReferencedAt('field = 5', true);
-  }
-
   void test_isReferencedBy_FieldElement() {
     _indexTestUnit('''
 class A {
   var field;
   A({this.field});
   m() {
-    field = 1; // nq
+    field = 2; // nq
     print(field); // nq
   }
 }
 main(A a) {
-  a.field = 2; // q
+  a.field = 3; // q
   print(a.field); // q
-  new A(field: 3);
+  new A(field: 4);
 }
 ''');
     FieldElement field = findElement('field');
     PropertyAccessorElement getter = field.getter;
     PropertyAccessorElement setter = field.setter;
     // A()
-    assertThat(field)..isReferencedAt('field});', true);
+    assertThat(field)..isWrittenAt('field});', true);
     // m()
-    assertThat(setter)..isReferencedAt('field = 1; // nq', false);
+    assertThat(setter)..isReferencedAt('field = 2; // nq', false);
     assertThat(getter)..isReferencedAt('field); // nq', false);
     // main()
-    assertThat(setter)..isReferencedAt('field = 2; // q', true);
+    assertThat(setter)..isReferencedAt('field = 3; // q', true);
     assertThat(getter)..isReferencedAt('field); // q', true);
-    assertThat(field)..isReferencedAt('field: 3', true);
+    assertThat(field)..isReferencedAt('field: 4', true);
   }
 
   void test_isReferencedBy_FunctionElement() {
     _indexTestUnit('''
 foo() {}
 main() {
   print(foo);
   print(foo());
 }
 ''');
@@ skipping 84 matching lines @@
 
   void test_isReferencedBy_typeInVariableList() {
     _indexTestUnit('''
 class A {}
 A myVariable = null;
 ''');
     Element element = findElement('A');
     assertThat(element).isReferencedAt('A myVariable', false);
   }
 
-  void test_usedName_isInvokedBy() {
+  void test_isWrittenBy_FieldElement() {
+    _indexTestUnit('''
+class A {
+  int field;
+  A.foo({this.field});
+  A.bar() : field = 5;
+}
+''');
+    FieldElement element = findElement('field');
+    assertThat(element)
+      ..isWrittenAt('field})', true)
+      ..isWrittenAt('field = 5', true);
+  }
+
+  void test_usedName_qualified_resolved() {
     verifyNoTestUnitErrors = false;
     _indexTestUnit('''
 class C {
-  x() {}
+  var x;
 }
 main(C c) {
-  x(); // nq
-  c.x(); // q
-  y(); // nq
-  c.y(); // q
+  c.x;
+  c.x = 1;
+  c.x += 2;
+  c.x();
 }
 ''');
     assertThatName('x')
-      ..isNotInvokedAt('x(); // nq')
-      ..isNotInvokedAt('x(); // q');
-    assertThatName('y')
-      ..isNotInvokedAt('y(); // nq')
-      ..isInvokedAt('y(); // q');
+      ..isNotUsed('x;', IndexRelationKind.IS_READ_BY)
+      ..isNotUsed('x = 1;', IndexRelationKind.IS_WRITTEN_BY)
+      ..isNotUsed('x += 2;', IndexRelationKind.IS_READ_WRITTEN_BY)
+      ..isNotUsed('x();', IndexRelationKind.IS_INVOKED_BY);
   }
 
-  void test_usedName_isReferencedBy() {
+  void test_usedName_qualified_unresolved() {
+    verifyNoTestUnitErrors = false;
+    _indexTestUnit('''
+main(p) {
+  p.x;
+  p.x = 1;
+  p.x += 2;
+  p.x();
+}
+''');
+    assertThatName('x')
+      ..isUsed('x;', IndexRelationKind.IS_READ_BY)
+      ..isUsed('x = 1;', IndexRelationKind.IS_WRITTEN_BY)
+      ..isUsed('x += 2;', IndexRelationKind.IS_READ_WRITTEN_BY)
+      ..isUsed('x();', IndexRelationKind.IS_INVOKED_BY);
+  }
+
+  void test_usedName_unqualified() {
     verifyNoTestUnitErrors = false;
     _indexTestUnit('''
 class C {
-  int x;
+  var x;
 }
-main(C c) {
-  x; // nq
-  c.x; // q
-  y; // nq
-  c.y; // q
+main() {
+  x;
+  x = 1;
+  x += 2;
+  x();
 }
 ''');
     assertThatName('x')
-      ..isNotReferencedAt('x; // nq')
-      ..isNotReferencedAt('x; // q');
-    assertThatName('y')
-      ..isNotReferencedAt('y; // nq')
-      ..isReferencedAt('y; // q');
+      ..isNotUsed('x;', IndexRelationKind.IS_READ_BY)
+      ..isNotUsed('x = 1;', IndexRelationKind.IS_WRITTEN_BY)
+      ..isNotUsed('x += 2;', IndexRelationKind.IS_READ_WRITTEN_BY)
+      ..isNotUsed('x();', IndexRelationKind.IS_INVOKED_BY);
   }
 
   void _assertDefinedName(String name, IndexNameKind kind, String search) {
     int offset = findOffset(search);
     int nameId = _getStringId(name);
     for (int i = 0; i < unitIndex.definedNames.length; i++) {
       if (unitIndex.definedNames[i] == nameId &&
           unitIndex.definedNameKinds[i] == kind &&
           unitIndex.definedNameOffsets[i] == offset) {
         return;
@@ skipping 184 matching lines @@
         test._expectedLocation(search, isQualified, length: length));
   }
 
   void isReferencedAt(String search, bool isQualified, {int length}) {
     test._assertHasRelation(
         element,
         relations,
         IndexRelationKind.IS_REFERENCED_BY,
         test._expectedLocation(search, isQualified, length: length));
   }
+
+  void isWrittenAt(String search, bool isQualified, {int length}) {
+    test._assertHasRelation(element, relations, IndexRelationKind.IS_WRITTEN_BY,
+        test._expectedLocation(search, isQualified, length: length));
+  }
 }
 
 class _NameIndexAssert {
   final PackageIndexAssemblerTest test;
   final String name;
 
   _NameIndexAssert(this.test, this.name);
 
-  void isInvokedAt(String search, {int length}) {
-    test._assertUsedName(name, IndexRelationKind.IS_INVOKED_BY,
-        test._expectedLocation(search, true, length: length), false);
+  void isNotUsed(String search, IndexRelationKind kind) {
+    test._assertUsedName(
+        name, kind, test._expectedLocation(search, true), true);
   }
 
-  void isNotInvokedAt(String search, {int length}) {
-    test._assertUsedName(name, IndexRelationKind.IS_INVOKED_BY,
-        test._expectedLocation(search, true, length: length), true);
-  }
-
-  void isNotReferencedAt(String search, {int length}) {
-    test._assertUsedName(name, IndexRelationKind.IS_REFERENCED_BY,
-        test._expectedLocation(search, true, length: length), true);
-  }
-
-  void isReferencedAt(String search, {int length}) {
-    test._assertUsedName(name, IndexRelationKind.IS_REFERENCED_BY,
-        test._expectedLocation(search, true, length: length), false);
+  void isUsed(String search, IndexRelationKind kind) {
+    test._assertUsedName(
+        name, kind, test._expectedLocation(search, true), false);
   }
 }
 
 class _Relation {
   final IndexRelationKind kind;
   final int offset;
   final int length;
   final bool isQualified;
 
   _Relation(this.kind, this.offset, this.length, this.isQualified);
 
   @override
   String toString() {
     return '_Relation{kind: $kind, offset: $offset, length: $length, '
         'isQualified: $isQualified}';
   }
 }