Compute names referenced in a unit.

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

Index: pkg/analyzer/test/src/dart/analysis/referenced_names_test.dart
diff --git a/pkg/analyzer/test/src/dart/analysis/referenced_names_test.dart b/pkg/analyzer/test/src/dart/analysis/referenced_names_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..369e52e62f168164ecedc33af95379b819b934e3
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/analysis/referenced_names_test.dart
@@ -0,0 +1,329 @@
+// 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/analysis/referenced_names.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../generated/parser_test.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ReferencedNamesBuilderTest);
+  });
+}
+
+@reflectiveTest
+class ReferencedNamesBuilderTest {

[Brian Wilkerson, 2016/11/18 17:55:51]

I might be missing something, but it seems to be missing tests to ensure that we
don't return names that are defined locally. Also, that we do return names that
match locally defined names where (a) the declaration is not in scope, or (b)
the declaration is qualified.

+  test_class_constructor() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  U.named(A a, B b) {
+    C c = null;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_class_field() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  A f = new B();
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_class_getter() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  A get a => new B();
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_class_members() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  int a;
+  int get b;
+  set c(_) {}
+  m(D d) {
+    a;
+    b;
+    c = 1;
+    m();
+  }
+}
+''');
+    expect(names, unorderedEquals(['int', 'D']));
+  }
+
+  test_class_members_dontHideQualified() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  int a;
+  int get b;
+  set c(_) {}
+  m(D d) {
+    d.a;
+    d.b;
+    d.c;
+  }
+}
+''');
+    expect(names, unorderedEquals(['int', 'D', 'a', 'b', 'c']));
+  }
+
+  test_class_method() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  A m(B p) {
+    C v = 0;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_class_method_localVariables() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  A m() {
+    B b = null;
+    b;
+    {
+      C c = null;
+      b;
+      c;
+    }
+    d;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'd']));
+  }
+
+  test_class_method_parameters() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  m(A a) {
+    a;
+    b;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'b']));
+  }
+
+  test_class_method_typeParameters() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  A m<T>(B b, T t) {
+    C c = 0;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_class_setter() {
+    Set<String> names = _computeReferencedNames('''
+class U {
+  set a(A a) {
+    B b = null;
+  }
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_class_typeParameters() {
+    Set<String> names = _computeReferencedNames('''
+class U<T> {
+  T f = new A<T>();
+}
+''');
+    expect(names, unorderedEquals(['A']));
+  }
+
+  test_instantiatedNames_importPrefix() {
+    Set<String> names = _computeReferencedNames('''
+import 'a.dart' as p1;
+import 'b.dart' as p2;
+main() {
+  new p1.A();
+  new p1.A.c1();
+  new p1.B();
+  new p2.C();
+  new D();
+  new D.c2();
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'D', 'c1', 'c2']));
+  }
+
+  test_localFunction() {
+    Set<String> names = _computeReferencedNames('''
+f(A a) {
+  g(B b) {}
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_superToSubs_importPrefix() {
+    Set<String> names = _computeReferencedNames('''
+import 'a.dart' as p1;
+import 'b.dart' as p2;
+class U extends p1.A with p2.B implements p2.C {}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_topLevelVariable() {
+    Set<String> names = _computeReferencedNames('''
+A v = new B(c);
+''');
+    expect(names, unorderedEquals(['A', 'B', 'c']));
+  }
+
+  test_topLevelVariable_multiple() {
+    Set<String> names = _computeReferencedNames('''
+A v1 = new B(c), v2 = new D<E>(f);
+''');
+    expect(names, unorderedEquals(['A', 'B', 'c', 'D', 'E', 'f']));
+  }
+
+  test_unit_classTypeAlias() {
+    Set<String> names = _computeReferencedNames('''
+class U = A with B implements C;
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_unit_classTypeAlias_typeParameters() {
+    Set<String> names = _computeReferencedNames('''
+class U<T1, T2 extends D> = A<T1> with B<T2> implements C<T1, T2>;
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'D']));
+  }
+
+  test_unit_function() {
+    Set<String> names = _computeReferencedNames('''
+A f(B b) {
+  C c = 0;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_unit_function_doc() {
+    Set<String> names = _computeReferencedNames('''
+/**
+ * Documentation [C.d] reference.
+ */
+A f(B b) {}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'd']));
+  }
+
+  test_unit_function_localFunctions() {
+    Set<String> names = _computeReferencedNames('''
+A f() {
+  B b = null;
+  C g() {}
+  g();
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_unit_function_localsDontHideQualified() {
+    Set<String> names = _computeReferencedNames('''
+f(A a, B b) {
+  var v = 0;
+  a.v;
+  a.b;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'v', 'b']));
+  }
+
+  test_unit_function_localVariables() {
+    Set<String> names = _computeReferencedNames('''
+A f() {
+  B b = null;
+  b;
+  {
+    C c = null;
+    b;
+    c;
+  }
+  d;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'd']));
+  }
+
+  test_unit_function_parameters() {
+    Set<String> names = _computeReferencedNames('''
+A f(B b) {
+  C c = 0;
+  b;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_unit_function_typeParameters() {
+    Set<String> names = _computeReferencedNames('''
+A f<T>(B b, T t) {
+  C c = 0;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C']));
+  }
+
+  test_unit_functionTypeAlias() {
+    Set<String> names = _computeReferencedNames('''
+typedef A F(B B, C c(D d));
+''');
+    expect(names, unorderedEquals(['A', 'B', 'C', 'D']));
+  }
+
+  test_unit_functionTypeAlias_typeParameters() {
+    Set<String> names = _computeReferencedNames('''
+typedef A F<T>(B b, T t);
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_unit_getter() {
+    Set<String> names = _computeReferencedNames('''
+A get aaa {
+  return new B();
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  test_unit_setter() {
+    Set<String> names = _computeReferencedNames('''
+set aaa(A a) {
+  B b = null;
+}
+''');
+    expect(names, unorderedEquals(['A', 'B']));
+  }
+
+  Set<String> _computeReferencedNames(String code) {
+    CompilationUnit unit =
+        ParserTestCase.parseCompilationUnit2(code, parseGenericMethods: true);
+    return computeReferencedNames(unit);
+  }
+}