Implement a task to compute the dependencies between static variables

pkg/analyzer/test/src/task/dart_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.dart_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 22 matching lines @@
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildEnumMemberElementsTaskTest);
   runReflectiveTests(BuildSourceExportClosureTaskTest);
   runReflectiveTests(BuildSourceImportExportClosureTaskTest);
   runReflectiveTests(BuildExportNamespaceTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ComputeConstantDependenciesTaskTest);
   runReflectiveTests(ComputeConstantValueTaskTest);
+  runReflectiveTests(ComputeInferableStaticVariableDependenciesTaskTest);
   runReflectiveTests(ContainingLibrariesTaskTest);
   runReflectiveTests(DartErrorsTaskTest);
   runReflectiveTests(EvaluateUnitConstantsTaskTest);
   runReflectiveTests(GatherUsedImportedElementsTaskTest);
   runReflectiveTests(GatherUsedLocalElementsTaskTest);
   runReflectiveTests(GenerateHintsTaskTest);
   runReflectiveTests(LibraryErrorsReadyTaskTest);
   runReflectiveTests(LibraryUnitErrorsTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(PartiallyResolveReferencesTaskTest);
   runReflectiveTests(ResolveUnitTypeNamesTaskTest);
   runReflectiveTests(ResolveLibraryTypeNamesTaskTest);
   runReflectiveTests(ResolveReferencesTaskTest);
   runReflectiveTests(ResolveVariableReferencesTaskTest);
   runReflectiveTests(ScanDartTaskTest);
   runReflectiveTests(VerifyUnitTaskTest);
 }
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   Source source;
   LibrarySpecificUnit target;
 
-  /**
-   * Enable strong mode in the current analysis context.
-   */
-  void enableStrongMode() {
-    AnalysisOptionsImpl options = context.analysisOptions;
-    options.strongMode = true;
-    context.analysisOptions = options;
-  }
-
   test_buildInputs() {
     LibrarySpecificUnit target =
         new LibrarySpecificUnit(emptySource, emptySource);
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
     expect(inputs, isNotNull);
     expect(
         inputs.keys,
         unorderedEquals(
             [BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME]));
@@ skipping 20 matching lines @@
         new BuildCompilationUnitElementTask(null, emptySource);
     expect(task.description, isNotNull);
   }
 
   test_descriptor() {
     TaskDescriptor descriptor = BuildCompilationUnitElementTask.DESCRIPTOR;
     expect(descriptor, isNotNull);
   }
 
   test_perform_find_constants_strong() {
-    enableStrongMode();
     _performBuildTask('''
 const x = 1;
 class C {
   static const y = 1;
   const C([p = 1]);
 }
 @x
 f() {
   const z = 1;
 }
 ''');
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     CompilationUnitElement unitElement = outputs[COMPILATION_UNIT_ELEMENT];
     Annotation annotation = unit.declarations
         .firstWhere((m) => m is FunctionDeclaration)
         .metadata[0];
     List<ConstantEvaluationTarget> expectedConstants = [
       unitElement.accessors.firstWhere((e) => e.isGetter).variable,
       unitElement.types[0].fields[0],
       unitElement.functions[0].localVariables[0],
       unitElement.types[0].constructors[0],
       new ConstantEvaluationTarget_Annotation(
           context, source, source, annotation),
       unitElement.types[0].constructors[0].parameters[0]
     ];
-    expect(outputs[CLASSES_IN_UNIT], hasLength(1));
     expect(
         outputs[COMPILATION_UNIT_CONSTANTS].toSet(), expectedConstants.toSet());
-    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(2));
   }
 
   test_perform_find_constants_weak() {

[Paul Berry, 2015/08/27 18:56:08]

It looks like this test is now the same as the previous one.  Consolidate them
into a single test.

[Brian Wilkerson, 2015/08/27 20:43:54]

Done

     _performBuildTask('''
 const x = 1;
 class C {
   static const y = 1;
   const C([p = 1]);
 }
 @x
 f() {
   const z = 1;
 }
 ''');
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     CompilationUnitElement unitElement = outputs[COMPILATION_UNIT_ELEMENT];
     Annotation annotation = unit.declarations
         .firstWhere((m) => m is FunctionDeclaration)
         .metadata[0];
     List<ConstantEvaluationTarget> expectedConstants = [
       unitElement.accessors.firstWhere((e) => e.isGetter).variable,
       unitElement.types[0].fields[0],
       unitElement.functions[0].localVariables[0],
       unitElement.types[0].constructors[0],
       new ConstantEvaluationTarget_Annotation(
           context, source, source, annotation),
       unitElement.types[0].constructors[0].parameters[0]
     ];
-    expect(outputs[CLASSES_IN_UNIT], hasLength(0));
     expect(
         outputs[COMPILATION_UNIT_CONSTANTS].toSet(), expectedConstants.toSet());
-    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(0));
   }
 
   test_perform_library_strong() {
-    enableStrongMode();
     _performBuildTask(r'''
 library lib;
 import 'lib2.dart';
 export 'lib3.dart';
 part 'part.dart';
 final x = '';
 class A {
   static final y = 0;
 }
 class B = Object with A;
 ''');
-    expect(outputs, hasLength(5));
-    expect(outputs[CLASSES_IN_UNIT], hasLength(2));
+    expect(outputs, hasLength(3));
     expect(outputs[COMPILATION_UNIT_CONSTANTS], isNotNull);
     expect(outputs[COMPILATION_UNIT_ELEMENT], isNotNull);
-    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(2));
     expect(outputs[RESOLVED_UNIT1], isNotNull);
   }
 
   test_perform_library_weak() {

[Paul Berry, 2015/08/27 18:56:08]

Same issue here.

[Brian Wilkerson, 2015/08/27 20:43:54]

Done

     _performBuildTask(r'''
 library lib;
 import 'lib2.dart';
 export 'lib3.dart';
 part 'part.dart';
 final x = '';
 class A {
   static final y = 0;
 }
 class B = Object with A;
 ''');
-    expect(outputs, hasLength(5));
-    expect(outputs[CLASSES_IN_UNIT], hasLength(0));
+    expect(outputs, hasLength(3));
     expect(outputs[COMPILATION_UNIT_CONSTANTS], isNotNull);
     expect(outputs[COMPILATION_UNIT_ELEMENT], isNotNull);
-    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(0));
     expect(outputs[RESOLVED_UNIT1], isNotNull);
   }
 
   test_perform_reuseElement() {
     _performBuildTask(r'''
 library lib;
 class A {}
 class B = Object with A;
 ''');
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
@@ skipping 1322 matching lines @@
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     return unit;
   }
 
   CompilationUnit _resolveUnit(String content) =>
       _resolveSource(newSource('/test.dart', content));
 }
 
 @reflectiveTest
+class ComputeInferableStaticVariableDependenciesTaskTest
+    extends _AbstractDartTaskTest {
+  test_perform() {
+    AnalysisTarget source = newSource(
+        '/test.dart',
+        '''
+const a = b;
+const b = 0;
+''');
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, RESOLVED_UNIT5);
+    CompilationUnit unit = outputs[RESOLVED_UNIT5];
+    TopLevelVariableElement elementA = unit.element.topLevelVariables[0];
+    TopLevelVariableElement elementB = unit.element.topLevelVariables[1];
+
+    computeResult(elementA, INFERABLE_STATIC_VARIABLE_DEPENDENCIES);
+    expect(task,
+        new isInstanceOf<ComputeInferableStaticVariableDependenciesTask>());
+    expect(outputs, hasLength(1));
+    Set<VariableElement> dependencies =
+        outputs[INFERABLE_STATIC_VARIABLE_DEPENDENCIES];
+    expect(dependencies, unorderedEquals([elementB]));
+  }
+}
+
+@reflectiveTest
 class ContainingLibrariesTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs =
         ContainingLibrariesTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
     expect(inputs, isEmpty);
   }
 
   test_constructor() {
     ContainingLibrariesTask task =
@@ skipping 760 matching lines @@
     expect(sources, hasLength(lenght));
     expect(sources, contains(predicate((Source s) {
       return s.fullName.endsWith('core.dart');
     })));
   }
 }
 
 @reflectiveTest
 class PartiallyResolveReferencesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
+    enableStrongMode();
     Source source = newSource(
         '/test.dart',
         '''
 int a = b;
 int b = c;
+var d = 0;
+class A {}
+class C {
+  static final f = '';
+  var g = 0;
+}
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5);
     expect(task, new isInstanceOf<PartiallyResolveUnitReferencesTask>());
     // Test the outputs
+    expect(outputs[CLASSES_IN_UNIT], hasLength(2));
+    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(2));
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     expect(unit, same(outputs[RESOLVED_UNIT5]));
     // Test the state of the AST
     TopLevelVariableDeclaration a = unit.declarations[0];
     VariableDeclaration variableA = a.variables.variables[0];
     SimpleIdentifier initializer = variableA.initializer;
     expect(initializer.staticElement, isNotNull);
     // Test the error generation
     _fillErrorListener(PARTIALLY_RESOLVE_REFERENCES_ERRORS);
     errorListener.assertErrorsWithCodes(
@@ skipping 20 matching lines @@
         '''
 library c;
 import 'b.dart';
 main() {
   new A<int>().m();
 }
 ''');
     computeResult(new LibrarySpecificUnit(sourceC, sourceC), RESOLVED_UNIT5);
     expect(task, new isInstanceOf<PartiallyResolveUnitReferencesTask>());
     // validate
+    expect(outputs[CLASSES_IN_UNIT], hasLength(0));
+    expect(outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT], hasLength(0));
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     expect(unit, isNotNull);
 
     FunctionDeclaration functionDeclaration = unit.declarations[0];
     BlockFunctionBody body = functionDeclaration.functionExpression.body;
     List<Statement> statements = body.block.statements;
     ExpressionStatement statement = statements[0];
     MethodInvocation invocation = statement.expression;
     MethodElement methodElement = invocation.methodName.staticElement;
     expect(methodElement, isNotNull);
@@ skipping 495 matching lines @@
     <script type='application/dart'>$scriptContent</script>
   </head>
   <body>Test</body>
 </html>
 ''';
     Source source = newSource('/test.html', htmlContent);
     return new DartScript(
         source, [new ScriptFragment(97, 5, 36, scriptContent)]);
   }
 
+  /**
+   * Enable strong mode in the current analysis context.
+   */
+  void enableStrongMode() {
+    AnalysisOptionsImpl options = context.analysisOptions;
+    options.strongMode = true;
+    context.analysisOptions = options;
+  }
+
   void setUp() {
     super.setUp();
     emptySource = newSource('/test.dart');
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }