Start implementing search support in AnalysisDriver.

pkg/analyzer/test/src/dart/analysis/search_test.dart

Index: pkg/analyzer/test/src/dart/analysis/search_test.dart
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..03a2a5316bdaa43d6b602c59e6f67cec0817b8a9
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -0,0 +1,168 @@
+// 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/element/element.dart';
+import 'package:analyzer/src/dart/analysis/search.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SearchTest);
+  });
+}
+
+class ExpectedResult {
+  final List<String> enclosingComponents;
+  final SearchResultKind kind;
+  final int offset;
+  final int length;
+  final bool isResolved;
+  final bool isQualified;
+
+  ExpectedResult(this.enclosingComponents, this.kind, this.offset, this.length,
+      {this.isResolved: true, this.isQualified: false});
+
+  bool operator ==(Object result) {
+    return result is SearchResult &&
+        result.kind == this.kind &&
+        result.isResolved == this.isResolved &&
+        result.isQualified == this.isQualified &&
+        result.offset == this.offset &&
+        hasExpectedComponents(result.enclosingElement);
+  }
+
+  bool hasExpectedComponents(Element element) {
+    for (int i = enclosingComponents.length - 1; i >= 0; i--) {
+      if (element == null) {
+        return false;
+      }
+      if (element is CompilationUnitElement) {
+        if (element.source.uri.toString() != enclosingComponents[0]) {
+          return false;
+        }
+      } else if (element.name != enclosingComponents[i]) {
+        return false;
+      }
+      element = element.enclosingElement;
+    }
+    return true;
+  }
+
+  @override
+  String toString() {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write("ExpectedResult(kind=");
+    buffer.write(kind);
+    buffer.write(", enclosingComponents=");
+    buffer.write(enclosingComponents);
+    buffer.write(", offset=");
+    buffer.write(offset);
+    buffer.write(", length=");
+    buffer.write(length);
+    buffer.write(", isResolved=");
+    buffer.write(isResolved);
+    buffer.write(", isQualified=");
+    buffer.write(isQualified);
+    buffer.write(")");
+    return buffer.toString();
+  }
+}
+
+@reflectiveTest
+class SearchTest extends BaseAnalysisDriverTest {
+  static const testUri = 'package:test/test.dart';
+
+  test_searchReferences_Label() async {
+    addTestFile('''
+main() {
+label:
+  while (true) {
+    if (true) {
+      break label; // 1
+    }
+    break label; // 2
+  }
+}
+''');
+    int offset = findOffset('label:');
+    List<String> main = [testUri, 'main'];
+    var expected = [
+      _expectId(main, SearchResultKind.REFERENCE, 'label; // 1'),
+      _expectId(main, SearchResultKind.REFERENCE, 'label; // 2')
+    ];
+    await _verifyReferences(offset, expected);
+  }
+
+  test_searchReferences_localVariable() async {
+    addTestFile(r'''
+main() {
+  var v;
+  v = 1;
+  v += 2;
+  print(v);
+  v();
+}
+''');
+    int offset = findOffset('v;');
+    List<String> main = [testUri, 'main'];
+    var expected = [
+      _expectId(main, SearchResultKind.WRITE, 'v = 1;'),
+      _expectId(main, SearchResultKind.READ_WRITE, 'v += 2;'),
+      _expectId(main, SearchResultKind.READ, 'v);'),
+      _expectId(main, SearchResultKind.INVOCATION, 'v();')
+    ];
+    await _verifyReferences(offset, expected);
+  }
+
+  test_searchReferences_localVariable_inForEachLoop() async {
+    addTestFile('''
+main() {
+  for (var v in []) {
+    v = 1;
+    v += 2;
+    print(v);
+    v();
+  }
+}
+''');
+    int offset = findOffset('v in []');
+    List<String> main = [testUri, 'main'];
+    var expected = [
+      _expectId(main, SearchResultKind.WRITE, 'v = 1;'),
+      _expectId(main, SearchResultKind.READ_WRITE, 'v += 2;'),
+      _expectId(main, SearchResultKind.READ, 'v);'),
+      _expectId(main, SearchResultKind.INVOCATION, 'v();')
+    ];
+    await _verifyReferences(offset, expected);
+  }
+
+  ExpectedResult _expectId(
+      List<String> enclosingComponents, SearchResultKind kind, String search,
+      {int length, bool isResolved: true, bool isQualified: false}) {
+    int offset = findOffset(search);
+    if (length == null) {
+      length = getLeadingIdentifierLength(search);
+    }
+    return new ExpectedResult(enclosingComponents, kind, offset, length,
+        isResolved: isResolved, isQualified: isQualified);
+  }
+
+  Future _verifyReferences(
+      int offset, List<ExpectedResult> expectedMatches) async {
+    List<SearchResult> results =
+        await driver.search.references(testFile, offset);
+    _assertResults(results, expectedMatches);
+    expect(results, hasLength(expectedMatches.length));
+  }
+
+  static void _assertResults(
+      List<SearchResult> matches, List<ExpectedResult> expectedMatches) {
+    expect(matches, unorderedEquals(expectedMatches));
+  }
+}