Include 'element' into 'search.findElementReferences' response.

pkg/analysis_server/test/search/element_references_test.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.
 
 library test.search.element_references;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/computer/element.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 12 matching lines @@
   groupSep = ' | ';
   group('findElementReferences', () {
     runReflectiveTests(ElementReferencesTest);
   });
 }
 
 
 @ReflectiveTestCase()
 class ElementReferencesTest extends AbstractAnalysisTest {
   String searchId;
+  Element searchElement;
   bool searchDone = false;
   List<SearchResult> results = <SearchResult>[];
   SearchResult result;
 
   void assertHasResult(SearchResultKind kind, String search, [int length]) {
     int offset = findOffset(search);
     if (length == null) {
       length = findIdentifierLength(search);
     }
     findResult(kind, testFile, offset, length, true);
@@ skipping 14 matching lines @@
 
   Future findElementReferences(String search, bool includePotential) {
     int offset = findOffset(search);
     return waitForTasksFinished().then((_) {
       Request request = new Request('0', SEARCH_FIND_ELEMENT_REFERENCES);
       request.setParameter(FILE, testFile);
       request.setParameter(OFFSET, offset);
       request.setParameter(INCLUDE_POTENTIAL, includePotential);
       Response response = handleSuccessfulRequest(request);
       searchId = response.getResult(ID);
+      searchElement = response.getResult(ELEMENT);
       results.clear();
       return _waitForSearchResults();
     });
   }
 
   void findResult(SearchResultKind kind, String file, int offset, int length,
       bool expected) {
     for (SearchResult result in results) {
       Location location = result.location;
       if (result.kind == kind &&
@@ skipping 43 matching lines @@
     addTestFile('''
 class A {
   A.named(p);
 }
 main() {
   new A.named(1);
   new A.named(2);
 }
 ''');
     return findElementReferences('named(p)', false).then((_) {
+      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
       assertHasResult(SearchResultKind.REFERENCE, '.named(1)', 6);
       assertHasResult(SearchResultKind.REFERENCE, '.named(2)', 6);
     });
   }
 
   test_constructor_unamed() {
     addTestFile('''
 class A {
   A(p);
 }
 main() {
   new A(1);
   new A(2);
 }
 ''');
     return findElementReferences('A(p)', false).then((_) {
+      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
       assertHasResult(SearchResultKind.REFERENCE, '(1)', 0);
       assertHasResult(SearchResultKind.REFERENCE, '(2)', 0);
     });
   }
 
   test_field_explicit() {
     addTestFile('''
 class A {
   var fff; // declaration
   A(this.fff); // in constructor
   m() {
     fff = 2;
     fff += 3;
     print(fff); // in m()
     fff(); // in m()
   }
 }
 main(A a) {
   a.fff = 20;
   a.fff += 30;
   print(a.fff); // in main()
   a.fff(); // in main()
 }
 ''');
     return findElementReferences('fff; // declaration', false).then((_) {
+      expect(searchElement.kind, ElementKind.FIELD);
       expect(results, hasLength(10));
       assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
       assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
       // m()
       assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
       assertHasResult(SearchResultKind.WRITE, 'fff += 3;');
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
       assertHasResult(SearchResultKind.INVOCATION, 'fff(); // in m()');
       // main()
       assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
@@ skipping 12 matching lines @@
     print(fff); // in m()
     fff = 1;
   }
 }
 main(A a) {
   print(a.fff); // in main()
   a.fff = 10;
 }
 ''');
     var forGetter = findElementReferences('fff =>', false).then((_) {
+      expect(searchElement.kind, ElementKind.FIELD);
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 1;');
       assertHasResult(SearchResultKind.READ, 'fff); // in main()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
     });
     var forSetter = findElementReferences('fff(x) {}', false).then((_) {
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 1;');
       assertHasResult(SearchResultKind.READ, 'fff); // in main()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
     });
     return Future.wait([forGetter, forSetter]);
   }
 
   test_field_inFormalParameter() {
     addTestFile('''
 class A {
   var fff; // declaration
   A(this.fff); // in constructor
   m() {
     fff = 2;
     print(fff); // in m()
   }
 }
 ''');
     return findElementReferences('fff); // in constructor', false).then((_) {
+      expect(searchElement.kind, ElementKind.FIELD);
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
       assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
       assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
     });
   }
 
   test_function() {
     addTestFile('''
 fff(p) {}
 main() {
   fff(1);
   print(fff);
 }
 ''');
     return findElementReferences('fff(p) {}', false).then((_) {
+      expect(searchElement.kind, ElementKind.FUNCTION);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.INVOCATION, 'fff(1)');
       assertHasResult(SearchResultKind.REFERENCE, 'fff);');
     });
   }
 
   test_hierarchy_field_explicit() {
     addTestFile('''
 class A {
   int fff; // in A
 }
 class B extends A {
   int fff; // in B
 }
 class C extends B {
   int fff; // in C
 }
 main(A a, B b, C c) {
   a.fff = 10;
   b.fff = 20;
   c.fff = 30;
 }
 ''');
     return findElementReferences('fff; // in B', false).then((_) {
+      expect(searchElement.kind, ElementKind.FIELD);
       assertHasResult(SearchResultKind.DECLARATION, 'fff; // in A');
       assertHasResult(SearchResultKind.DECLARATION, 'fff; // in B');
       assertHasResult(SearchResultKind.DECLARATION, 'fff; // in C');
       assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
       assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
       assertHasResult(SearchResultKind.WRITE, 'fff = 30;');
     });
   }
 
   test_hierarchy_method() {
     addTestFile('''
 class A {
   mmm() {} // in A
 }
 class B extends A {
   mmm() {} // in B
 }
 class C extends B {
   mmm() {} // in C
 }
 main(A a, B b, C c) {
   a.mmm(10);
   b.mmm(20);
   c.mmm(30);
 }
 ''');
     return findElementReferences('mmm() {} // in B', false).then((_) {
+      expect(searchElement.kind, ElementKind.METHOD);
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(10)');
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(20)');
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(30)');
     });
   }
 
   test_localVariable() {
     addTestFile('''
 main() {
   var vvv = 1;
   print(vvv);
   vvv += 3;
   vvv = 2;
   vvv();
 }
 ''');
     return findElementReferences('vvv = 1', false).then((_) {
+      expect(searchElement.kind, ElementKind.LOCAL_VARIABLE);
       expect(results, hasLength(5));
       assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1');
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.READ_WRITE, 'vvv += 3');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
       assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
     });
   }
 
   test_method() {
     addTestFile('''
 class A {
   mmm(p) {}
   m() {
     mmm(1);
     print(mmm); // in m()
   }
 }
 main(A a) {
   a.mmm(10);
   print(a.mmm); // in main()
 }
 ''');
     return findElementReferences('mmm(p) {}', false).then((_) {
+      expect(searchElement.kind, ElementKind.METHOD);
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(1);');
       assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in m()');
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
       assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in main()');
     });
   }
 
   test_method_propagatedType() {
     addTestFile('''
 class A {
   mmm(p) {}
 }
 main() {
   var a = new A();
   a.mmm(10);
   print(a.mmm);
 }
 ''');
     return findElementReferences('mmm(p) {}', false).then((_) {
+      expect(searchElement.kind, ElementKind.METHOD);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
       assertHasResult(SearchResultKind.REFERENCE, 'mmm);');
     });
   }
 
   test_oneUnit_twoLibraries() {
     var pathA = '/project/bin/libA.dart';
     var pathB = '/project/bin/libB.dart';
     var codeA = '''
@@ skipping 10 matching lines @@
   fff(2);
 }
 ''';
     addFile(pathA, codeA);
     addFile(pathB, codeB);
     addTestFile('''
 part of lib;
 fff(p) {}
 ''');
     return findElementReferences('fff(p) {}', false).then((_) {
+      expect(searchElement.kind, ElementKind.FUNCTION);
       expect(results, hasLength(2));
       findResult(
           SearchResultKind.INVOCATION,
           pathA,
           codeA.indexOf('fff(1)'),
           3,
           true);
       findResult(
           SearchResultKind.INVOCATION,
           pathB,
@@ skipping 19 matching lines @@
   test_parameter() {
     addTestFile('''
 main(ppp) {
   print(ppp);
   ppp += 3;
   ppp = 2;
   ppp();
 }
 ''');
     return findElementReferences('ppp) {', false).then((_) {
+      expect(searchElement.kind, ElementKind.PARAMETER);
       expect(results, hasLength(5));
       assertHasResult(SearchResultKind.DECLARATION, 'ppp) {');
       assertHasResult(SearchResultKind.READ, 'ppp);');
       assertHasResult(SearchResultKind.READ_WRITE, 'ppp += 3');
       assertHasResult(SearchResultKind.WRITE, 'ppp = 2');
       assertHasResult(SearchResultKind.INVOCATION, 'ppp();');
     });
   }
 
   test_path_inConstructor_named() {
@@ skipping 125 matching lines @@
     addTestFile('''
 var vvv = 1;
 main() {
   print(vvv);
   vvv += 3;
   vvv = 2;
   vvv();
 }
 ''');
     return findElementReferences('vvv = 1', false).then((_) {
+      expect(searchElement.kind, ElementKind.TOP_LEVEL_VARIABLE);
       expect(results, hasLength(5));
       assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1;');
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.WRITE, 'vvv += 3');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
       assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
     });
   }
 
   test_topLevelVariable_implicit() {
     addTestFile('''
 get vvv => null;
 set vvv(x) {}
 main() {
   print(vvv);
   vvv = 1;
 }
 ''');
     var forGetter = findElementReferences('vvv =>', false).then((_) {
+      expect(searchElement.kind, ElementKind.TOP_LEVEL_VARIABLE);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 1;');
     });
     var forSetter = findElementReferences('vvv(x) {}', false).then((_) {
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 1;');
     });
     return Future.wait([forGetter, forSetter]);
   }
 
   test_typeReference_class() {
     addTestFile('''
 main() {
   int a = 1;
   int b = 2;
 }
 ''');
     return findElementReferences('int a', false).then((_) {
+      expect(searchElement.kind, ElementKind.CLASS);
       assertHasResult(SearchResultKind.REFERENCE, 'int a');
       assertHasResult(SearchResultKind.REFERENCE, 'int b');
     });
   }
 
   test_typeReference_functionType() {
     addTestFile('''
 typedef F();
 main(F f) {
 }
 ''');
     return findElementReferences('F()', false).then((_) {
+      expect(searchElement.kind, ElementKind.FUNCTION_TYPE_ALIAS);
       expect(results, hasLength(1));
       assertHasResult(SearchResultKind.REFERENCE, 'F f');
     });
   }
 
   test_typeReference_typeVariable() {
     addTestFile('''
 class A<T> {
   T f;
   T m() => null;
 }
 ''');
     return findElementReferences('T> {', false).then((_) {
+      expect(searchElement.kind, ElementKind.TYPE_PARAMETER);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.REFERENCE, 'T f;');
       assertHasResult(SearchResultKind.REFERENCE, 'T m()');
     });
   }
 
   Future _waitForSearchResults() {
     if (searchDone) {
       return new Future.value();
     }
     return new Future.delayed(Duration.ZERO, _waitForSearchResults);
   }
 }