Implement a task to compute the dependencies between static variables

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 143 matching lines @@
 /**
  * The sources representing the combined import/export closure of a library.
  * The [Source]s include only library sources, not their units.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ListResultDescriptor<Source> IMPORT_EXPORT_SOURCE_CLOSURE =
     new ListResultDescriptor<Source>('IMPORT_EXPORT_SOURCE_CLOSURE', null);
 
 /**
+ * A list of the [VariableElement]s whose type should be inferred that another
+ * inferable static variable (the target) depends on.
+ *
+ * The result is only available for [VariableElement]s, and only when strong
+ * mode is enabled.
+ */
+final ListResultDescriptor<
+        VariableElement> INFERABLE_STATIC_VARIABLE_DEPENDENCIES =
+    new ListResultDescriptor<VariableElement>(
+        'INFERABLE_STATIC_VARIABLE_DEPENDENCIES', null);
+
+/**
  * A list of the [VariableElement]s defined in a unit whose type should be
  * inferred. This includes variables defined at the library level as well as
  * static members inside classes.
  *
  * The result is only available for [LibrarySpecificUnit]s, and only when strong
  * mode is enabled.
  */
 final ListResultDescriptor<VariableElement> INFERABLE_STATIC_VARIABLES_IN_UNIT =
     new ListResultDescriptor<VariableElement>(
         'INFERABLE_STATIC_VARIABLES_IN_UNIT', null);
@@ skipping 289 matching lines @@
    */
   static const String PARSED_UNIT_INPUT_NAME = 'PARSED_UNIT_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildCompilationUnitElementTask',
       createTask,
       buildInputs, <ResultDescriptor>[
-    CLASSES_IN_UNIT,
     COMPILATION_UNIT_CONSTANTS,
     COMPILATION_UNIT_ELEMENT,
-    INFERABLE_STATIC_VARIABLES_IN_UNIT,
     RESOLVED_UNIT1
   ]);
 
   /**
    * Initialize a newly created task to build a compilation unit element for
    * the given [target] in the given [context].
    */
   BuildCompilationUnitElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
@@ skipping 26 matching lines @@
     }
     //
     // Prepare constants.
     //
     ConstantFinder constantFinder =
         new ConstantFinder(context, source, librarySpecificUnit.library);
     unit.accept(constantFinder);
     List<ConstantEvaluationTarget> constants = new List<
         ConstantEvaluationTarget>.from(constantFinder.constantsToCompute);
     //
-    // Prepare targets for inference.
-    //
-    List<VariableElement> staticVariables = <VariableElement>[];
-    List<ClassElement> classes = <ClassElement>[];
-    if (context.analysisOptions.strongMode) {
-      InferrenceFinder inferrenceFinder = new InferrenceFinder();
-      unit.accept(inferrenceFinder);
-      staticVariables = inferrenceFinder.staticVariables;
-      classes = inferrenceFinder.classes;
-    }
-    //
     // Record outputs.
     //
-    outputs[CLASSES_IN_UNIT] = classes;
     outputs[COMPILATION_UNIT_CONSTANTS] = constants;
     outputs[COMPILATION_UNIT_ELEMENT] = element;
-    outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = staticVariables;
     outputs[RESOLVED_UNIT1] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
@@ skipping 932 matching lines @@
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: UNIT_INPUT is not needed.  It is merely a bookkeeping dependency
     // to ensure that resolution has occurred before we attempt to determine
     // constant dependencies.
     //
     ConstantEvaluationTarget constant = target;
-    AnalysisContext context = constant.context;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Compute dependencies.
     //
     List<ConstantEvaluationTarget> dependencies = <ConstantEvaluationTarget>[];
     new ConstantEvaluationEngine(typeProvider, context.declaredVariables)
         .computeDependencies(constant, dependencies.add);
     //
     // Record outputs.
     //
@@ skipping 19 matching lines @@
         UNIT_INPUT: RESOLVED_UNIT8
             .of(new LibrarySpecificUnit(target.librarySource, target.source)),
         TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
       };
     }
     throw new AnalysisException(
         'Cannot build inputs for a ${target.runtimeType}');
   }
 
   /**
-   * Create a [ResolveUnitReferencesTask] based on the given [target] in
+   * Create a [ComputeConstantDependenciesTask] based on the given [target] in
    * the given [context].
    */
   static ComputeConstantDependenciesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeConstantDependenciesTask(context, target);
   }
 }
 
 /**
  * A task that computes the value of a constant ([CONSTANT_VALUE]) and
@@ skipping 81 matching lines @@
    * Create a [ComputeConstantValueTask] based on the given [target] in the
    * given [context].
    */
   static ComputeConstantValueTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ComputeConstantValueTask(context, target);
   }
 }
 
 /**
+ * A task that computes the [INFERABLE_STATIC_VARIABLE_DEPENDENCIES] for a
+ * static variable whose type should be inferred.
+ */
+class ComputeInferableStaticVariableDependenciesTask
+    extends ConstantEvaluationAnalysisTask {
+  /**
+   * The name of the [RESOLVED_UNIT5] input.
+   */
+  static const String UNIT_INPUT = 'UNIT_INPUT';
+
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'ComputeInferableStaticVariableDependenciesTask',
+      createTask,
+      buildInputs,
+      <ResultDescriptor>[INFERABLE_STATIC_VARIABLE_DEPENDENCIES]);
+
+  ComputeInferableStaticVariableDependenciesTask(
+      InternalAnalysisContext context, VariableElement variable)
+      : super(context, variable);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    //
+    // Prepare inputs.
+    //
+    VariableElement variable = target;
+    CompilationUnit unit = getRequiredInput(UNIT_INPUT);
+    //
+    // Compute dependencies.
+    //
+    NodeLocator locator = new NodeLocator(variable.nameOffset);
+    AstNode node = locator.searchWithin(unit);
+    VariableDeclaration declaration =
+        node.getAncestor((AstNode ancestor) => ancestor is VariableDeclaration);
+    if (declaration == null || declaration.name != node) {
+      throw new AnalysisException(
+          "NodeLocator failed to find a variable's declaration");
+    }
+    VariableGatherer gatherer = new VariableGatherer(_isInferableStatic);
+    declaration.initializer.accept(gatherer);
+    //
+    // Record outputs.
+    //
+    outputs[INFERABLE_STATIC_VARIABLE_DEPENDENCIES] = gatherer.results;
+  }
+
+  /**
+   * Return `true` if the given [variable] is a static variable whose type
+   * should be inferred.
+   */
+  bool _isInferableStatic(VariableElement variable) => variable.isStatic &&
+      variable.hasImplicitType &&
+      variable.initializer != null;
+
+  /**
+   * Return a map from the names of the inputs of this kind of task to the task
+   * input descriptors describing those inputs for a task with the
+   * given [target].
+   */
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    if (target is VariableElement) {
+      CompilationUnitElementImpl unit = target
+          .getAncestor((Element element) => element is CompilationUnitElement);
+      return <String, TaskInput>{
+        UNIT_INPUT: RESOLVED_UNIT5
+            .of(new LibrarySpecificUnit(unit.librarySource, unit.source))
+      };
+    }
+    throw new AnalysisException(
+        'Cannot build inputs for a ${target.runtimeType}');
+  }
+
+  /**
+   * Create a [ComputeInferableStaticVariableDependenciesTask] based on the
+   * given [target] in the given [context].
+   */
+  static ComputeInferableStaticVariableDependenciesTask createTask(
+      AnalysisContext context, AnalysisTarget target) {
+    return new ComputeInferableStaticVariableDependenciesTask(context, target);
+  }
+}
+
+/**
  * A base class for analysis tasks whose target is expected to be a
  * [ConstantEvaluationTarget].
  */
 abstract class ConstantEvaluationAnalysisTask extends AnalysisTask {
   /**
    * Initialize a newly created task to perform analysis within the given
    * [context] in order to produce results for the given [constant].
    */
   ConstantEvaluationAnalysisTask(
       AnalysisContext context, ConstantEvaluationTarget constant)
@@ skipping 1018 matching lines @@
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'PartiallyResolveUnitReferencesTask',
       createTask,
-      buildInputs,
-      <ResultDescriptor>[PARTIALLY_RESOLVE_REFERENCES_ERRORS, RESOLVED_UNIT5]);
+      buildInputs, <ResultDescriptor>[
+    CLASSES_IN_UNIT,
+    INFERABLE_STATIC_VARIABLES_IN_UNIT,
+    PARTIALLY_RESOLVE_REFERENCES_ERRORS,
+    RESOLVED_UNIT5
+  ]);
 
   PartiallyResolveUnitReferencesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
@@ skipping 11 matching lines @@
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
     // TODO(brianwilkerson) Improve performance by not resolving anything inside
     // function bodies. Function bodies will be resolved later so this is wasted
     // effort.
     AstVisitor visitor = new ResolverVisitor(
         libraryElement, unitElement.source, typeProvider, errorListener,
         inheritanceManager: inheritanceManager);
     unit.accept(visitor);
     //
+    // Prepare targets for inference.
+    //
+    List<VariableElement> staticVariables = <VariableElement>[];
+    List<ClassElement> classes = <ClassElement>[];
+    if (context.analysisOptions.strongMode) {
+      InferrenceFinder inferrenceFinder = new InferrenceFinder();
+      unit.accept(inferrenceFinder);
+      staticVariables = inferrenceFinder.staticVariables;
+      classes = inferrenceFinder.classes;
+    }
+    //
     // Record outputs.
     //
+    outputs[CLASSES_IN_UNIT] = classes;
+    outputs[INFERABLE_STATIC_VARIABLES_IN_UNIT] = staticVariables;
     outputs[PARTIALLY_RESOLVE_REFERENCES_ERRORS] =
         removeDuplicateErrors(errorListener.errors);
     outputs[RESOLVED_UNIT5] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
@@ skipping 904 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }