Implement a task to compute the dependencies between static variables

pkg/analyzer/test/src/task/strong_mode_test.dart

 // Copyright (c) 2015, 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.src.task.strong_mode_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/testing/element_factory.dart';
+import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/strong_mode.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../reflective_tests.dart';
 import '../../utils.dart';
 import '../context/abstract_context.dart';
 
 main() {
   initializeTestEnvironment();
+  runReflectiveTests(DeclarationFinderTest);
   runReflectiveTests(InferrenceFinderTest);
   runReflectiveTests(InstanceMemberInferrerTest);
+  runReflectiveTests(VariableGathererTest);
 }
 
 @reflectiveTest
+class DeclarationFinderTest extends AbstractContextTest {
+  void test_creation() {
+    VariableElement variable = ElementFactory.topLevelVariableElement2('X');
+    DeclarationFinder finder = new DeclarationFinder(variable);
+    expect(finder, isNotNull);
+    expect(finder.targetElement, variable);
+  }
+
+  void test_find() {
+    String content = '''
+class C {
+  int x;
+}
+''';
+    Source source = addSource('/test.dart', content);
+    CompilationUnit unit = context.resolveCompilationUnit2(source, source);
+    NodeLocator locator = new NodeLocator(content.indexOf('x'));
+    SimpleIdentifier identifier = locator.searchWithin(unit);
+    VariableDeclaration result =
+        DeclarationFinder.find(unit, identifier.staticElement);
+    expect(result, identifier.parent);
+  }
+}
+
+@reflectiveTest
 class InferrenceFinderTest extends AbstractContextTest {
   void test_creation() {
     InferrenceFinder finder = new InferrenceFinder();
     expect(finder, isNotNull);
     expect(finder.classes, isEmpty);
     expect(finder.staticVariables, isEmpty);
   }
 
   void test_visit() {
     Source source = addSource(
         '/test.dart',
         r'''
 const c = 1;
 final f = '';
 var v = const A();
+int i;
 class A {
   static final fa = 0;
+  static int fi;
   const A();
 }
 class B extends A {
   static const cb = 1;
   static vb = 0;
   const ci = 2;
   final fi = '';
   var vi;
 }
 class C = Object with A;
 typedef int F(int x);
 ''');
-    computeResult(source, PARSED_UNIT);
-    CompilationUnit unit = outputs[PARSED_UNIT];
+    LibrarySpecificUnit librarySpecificUnit =
+        new LibrarySpecificUnit(source, source);
+    computeResult(librarySpecificUnit, RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
     InferrenceFinder finder = new InferrenceFinder();
     unit.accept(finder);
     expect(finder.classes, hasLength(3));
     expect(finder.staticVariables, hasLength(6));
   }
 }
 
 @reflectiveTest
 class InstanceMemberInferrerTest extends AbstractContextTest {
   InstanceMemberInferrer get createInferrer =>
@@ skipping 804 matching lines @@
 ''');
     ClassElement classB = unit.getType('B');
     MethodElement methodB = classB.getMethod(methodName);
     expect(methodB.returnType.isDynamic, isTrue);
 
     inferrer.inferCompilationUnit(unit);
 
     expect(methodB.returnType, classB.typeParameters[0].type);
   }
 }
+
+@reflectiveTest
+class VariableGathererTest extends AbstractContextTest {
+  void test_creation_withFilter() {
+    VariableFilter filter = (variable) => true;
+    VariableGatherer gatherer = new VariableGatherer(filter);
+    expect(gatherer, isNotNull);
+    expect(gatherer.filter, filter);
+  }
+
+  void test_creation_withoutFilter() {
+    VariableGatherer gatherer = new VariableGatherer();
+    expect(gatherer, isNotNull);
+    expect(gatherer.filter, isNull);
+  }
+
+  void test_visit_noReferences() {
+    Source source = addSource(
+        '/test.dart',
+        '''
+library lib;
+import 'dart:math';
+int zero = 0;
+class C {
+  void m() => null;
+}
+typedef void F();
+''');
+    CompilationUnit unit = context.resolveCompilationUnit2(source, source);
+    VariableGatherer gatherer = new VariableGatherer();
+    unit.accept(gatherer);
+    expect(gatherer.results, hasLength(0));
+  }
+
+  void test_visit_withFilter() {
+    VariableFilter filter = (VariableElement variable) => variable.isStatic;
+    expect(_gather(filter), hasLength(1));
+  }
+
+  void test_visit_withoutFilter() {
+    expect(_gather(), hasLength(4));
+  }
+
+  Set<VariableElement> _gather([VariableFilter filter = null]) {
+    Source source = addSource(
+        '/test.dart',
+        '''
+const int zero = 0;
+class Counter {
+  int value = zero;
+  void inc() {
+    value++;
+  }
+  void dec() {
+    value = value - 1;
+  }
+  void fromZero(f(int index)) {
+    for (int i = zero; i < value; i++) {
+      f(i);
+    }
+  }
+}
+''');
+    CompilationUnit unit = context.resolveCompilationUnit2(source, source);
+    VariableGatherer gatherer = new VariableGatherer(filter);
+    unit.accept(gatherer);
+    return gatherer.results;
+  }
+}