Use separate relation kinds for qualified usages.

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 90 matching lines @@
     _indexTestUnit('''
 class A {
   var field;
   main() {
     this.field(); // q
     field(); // nq
   }
 }''');
     FieldElement field = findElement('field');
     assertThat(field.getter)
-      ..isInvokedAt('field(); // q', qualified: true)
+      ..isInvokedQualifiedAt('field(); // q')
       ..isInvokedAt('field(); // nq');
   }
 
   void test_isInvokedBy_FunctionElement() {
     addSource(
         '/lib.dart',
         '''
 library lib;
 foo() {}
 ''');
     _indexTestUnit('''
 import 'lib.dart';
 import 'lib.dart' as pref;
 main() {
   pref.foo(); // q
   foo(); // nq
 }''');
     FunctionElement element = importedUnit().functions[0];
     assertThat(element)
-      ..isInvokedAt('foo(); // q', qualified: true)
+      ..isInvokedQualifiedAt('foo(); // q')
       ..isInvokedAt('foo(); // nq');
   }
 
   void test_isInvokedBy_MethodElement() {
     _indexTestUnit('''
 class A {
   foo() {}
   main() {
     this.foo(); // q
     foo(); // nq
   }
 }''');
     Element element = findElement('foo');
     assertThat(element)
-      ..isInvokedAt('foo(); // q', qualified: true)
+      ..isInvokedQualifiedAt('foo(); // q')
       ..isInvokedAt('foo(); // nq');
   }
 
   void test_isInvokedBy_MethodElement_propagatedType() {
     _indexTestUnit('''
 class A {
   foo() {}
 }
 main() {
   var a = new A();
   a.foo();
 }
 ''');
     Element element = findElement('foo');
-    assertThat(element).isInvokedAt('foo();', qualified: true);
+    assertThat(element).isInvokedQualifiedAt('foo();');
   }
 
   void test_isInvokedBy_operator_binary() {
     _indexTestUnit('''
 class A {
   operator +(other) => this;
 }
 main(A a) {
   print(a + 1);
   a += 2;
@@ skipping 231 matching lines @@
 ''');
     FieldElement field = findElement('field');
     PropertyAccessorElement getter = field.getter;
     PropertyAccessorElement setter = field.setter;
     // A()
     assertThat(field)..isReferencedAt('field});');
     // m()
     assertThat(setter)..isReferencedAt('field = 1; // nq');
     assertThat(getter)..isReferencedAt('field); // nq');
     // main()
-    assertThat(setter)..isReferencedAt('field = 2; // q', qualified: true);
-    assertThat(getter)..isReferencedAt('field); // q', qualified: true);
+    assertThat(setter)..isReferencedQualifiedAt('field = 2; // q');
+    assertThat(getter)..isReferencedQualifiedAt('field); // q');
     assertThat(field)..isReferencedAt('field: 3');
   }
 
   void test_isReferencedBy_FunctionElement() {
     _indexTestUnit('''
 foo() {}
 main() {
   print(foo);
   print(foo());
 }
@@ skipping 35 matching lines @@
     _indexTestUnit('''
 class A {
   method() {}
   main() {
     print(this.method); // q
     print(method); // nq
   }
 }''');
     MethodElement element = findElement('method');
     assertThat(element)
-      ..isReferencedAt('method); // q', qualified: true)
+      ..isReferencedQualifiedAt('method); // q')
       ..isReferencedAt('method); // nq');
   }
 
   void test_isReferencedBy_ParameterElement() {
     _indexTestUnit('''
 foo({var p}) {}
 main() {
   foo(p: 1);
 }
 ''');
@@ skipping 13 matching lines @@
 import 'lib.dart' as pref;
 main() {
   pref.V = 5; // q
   print(pref.V); // q
   V = 5; // nq
   print(V); // nq
 }''');
     TopLevelVariableElement variable = importedUnit().topLevelVariables[0];
     assertThat(variable)..isReferencedAt('V; // imp');
     assertThat(variable.getter)
-      ..isReferencedAt('V); // q', qualified: true)
+      ..isReferencedQualifiedAt('V); // q')
       ..isReferencedAt('V); // nq');
     assertThat(variable.setter)
-      ..isReferencedAt('V = 5; // q', qualified: true)
+      ..isReferencedQualifiedAt('V = 5; // q')
       ..isReferencedAt('V = 5; // nq');
   }
 
   void test_isReferencedBy_typeInVariableList() {
     _indexTestUnit('''
 class A {}
 A myVariable = null;
 ''');
     Element element = findElement('A');
     assertThat(element).isReferencedAt('A myVariable');
@@ skipping 113 matching lines @@
   void isExtendedAt(String search, {int length}) {
     test._assertHasRelation(element, IndexRelationKind.IS_EXTENDED_BY,
         test._expectedLocation(search, length: length));
   }
 
   void isImplementedAt(String search, {int length}) {
     test._assertHasRelation(element, IndexRelationKind.IS_IMPLEMENTED_BY,
         test._expectedLocation(search, length: length));
   }
 
-  void isInvokedAt(String search, {int length, bool qualified: false}) {
-    // TODO(scheglov) use 'qualified'
+  void isInvokedAt(String search, {int length}) {
     test._assertHasRelation(element, IndexRelationKind.IS_INVOKED_BY,
         test._expectedLocation(search, length: length));
   }
 
+  void isInvokedQualifiedAt(String search, {int length}) {
+    test._assertHasRelation(element, IndexRelationKind.IS_INVOKED_QUALIFIED_BY,
+        test._expectedLocation(search, length: length));
+  }
+
   void isMixedInAt(String search, {int length}) {
     test._assertHasRelation(element, IndexRelationKind.IS_MIXED_IN_BY,
         test._expectedLocation(search, length: length));
   }
 
-  void isReferencedAt(String search, {int length, bool qualified: false}) {
-    // TODO(scheglov) use 'qualified'
+  void isReferencedAt(String search, {int length}) {
     test._assertHasRelation(element, IndexRelationKind.IS_REFERENCED_BY,
         test._expectedLocation(search, length: length));
   }
+
+  void isReferencedQualifiedAt(String search, {int length}) {
+    test._assertHasRelation(
+        element,
+        IndexRelationKind.IS_REFERENCED_QUALIFIED_BY,
+        test._expectedLocation(search, length: length));
+  }
 }