Create a task in the new task model to compute constant dependencies.

pkg/analyzer/lib/src/generated/constant.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_general.dart';
 
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine, RecordingErrorListener;
 import 'error.dart';
 import 'java_core.dart';
 import 'resolver.dart' show TypeProvider;
 import 'scanner.dart' show Token, TokenType;
 import 'source.dart' show Source;
 import 'utilities_collection.dart';
 import 'utilities_dart.dart' show ParameterKind;
 
 /**
+ * Callback used by [ReferenceFinder] to report that a dependency was found.
+ */
+typedef void ReferenceFinderCallback(Element dependency);
+
+/**
  * The state of an object representing a boolean value.
  */
 class BoolState extends InstanceState {
   /**
    * An instance representing the boolean value 'false'.
    */
   static BoolState FALSE_STATE = new BoolState(false);
 
   /**
    * An instance representing the boolean value 'true'.
@@ skipping 143 matching lines @@
   SuperConstructorInvocation visitSuperConstructorInvocation(
       SuperConstructorInvocation node) {
     SuperConstructorInvocation invocation =
         super.visitSuperConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
   }
 }
 
 /**
- * Helper class encapsulating the methods for evaluating constant instance
+ * Helper class encapsulating the methods for evaluating constants and
  * constant instance creation expressions.
  */
 class ConstantEvaluationEngine {
   /**
    * Parameter to "fromEnvironment" methods that denotes the default value.
    */
   static String _DEFAULT_VALUE_PARAM = "defaultValue";
 
   /**
    * Source of RegExp matching any public identifier.
@@ skipping 96 matching lines @@
       return false;
     }
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
     }
     String name = argumentValues[0].stringValue;
     return isValidPublicSymbol(name);
   }
 
   /**
+   * Determine which constant elements need to have their values computed
+   * prior to computing the value of [element], and report them using
+   * [callback].
+   */
+  void computeDependencies(Element element, ReferenceFinderCallback callback) {
+    ReferenceFinder referenceFinder = new ReferenceFinder(callback);
+    if (element is ParameterElement) {
+      if (element.initializer != null) {
+        Expression defaultValue =
+            (element as ConstVariableElement).constantInitializer;
+        if (defaultValue != null) {
+          defaultValue.accept(referenceFinder);
+        }
+      }
+    } else if (element is PotentiallyConstVariableElement) {
+      element.constantInitializer.accept(referenceFinder);
+    } else if (element is ConstructorElementImpl) {
+      element.isCycleFree = false;
+      ConstructorElement redirectedConstructor =
+          getConstRedirectedConstructor(element);
+      if (redirectedConstructor != null) {
+        ConstructorElement redirectedConstructorBase =
+            ConstantEvaluationEngine._getConstructorBase(redirectedConstructor);
+        callback(redirectedConstructorBase);
+        return;
+      }
+      bool superInvocationFound = false;
+      List<ConstructorInitializer> initializers = element.constantInitializers;
+      for (ConstructorInitializer initializer in initializers) {
+        if (initializer is SuperConstructorInvocation) {
+          superInvocationFound = true;
+        }
+        initializer.accept(referenceFinder);
+      }
+      if (!superInvocationFound) {
+        // No explicit superconstructor invocation found, so we need to
+        // manually insert a reference to the implicit superconstructor.
+        InterfaceType superclass =
+            (element.returnType as InterfaceType).superclass;
+        if (superclass != null && !superclass.isObject) {
+          ConstructorElement unnamedConstructor = ConstantEvaluationEngine
+              ._getConstructorBase(superclass.element.unnamedConstructor);
+          if (unnamedConstructor != null) {
+            callback(unnamedConstructor);
+          }
+        }
+      }
+      for (FieldElement field in element.enclosingElement.fields) {
+        // Note: non-static const isn't allowed but we handle it anyway so that
+        // we won't be confused by incorrect code.
+        if ((field.isFinal || field.isConst) &&
+            !field.isStatic &&
+            field.initializer != null) {
+          callback(field);
+        }
+      }
+      for (ParameterElement parameterElement in element.parameters) {
+        callback(parameterElement);
+      }
+    } else {
+      // Should not happen.
+      assert(false);
+      AnalysisEngine.instance.logger.logError(
+          "Constant value computer trying to compute the value of a node of type ${element.runtimeType}");
+    }
+  }
+
+  /**
    * Evaluate a call to fromEnvironment() on the bool, int, or String class. The
    * [environmentValue] is the value fetched from the environment. The
    * [builtInDefaultValue] is the value that should be used as the default if no
    * "defaultValue" argument appears in [namedArgumentValues]. The
    * [namedArgumentValues] are the values of the named parameters passed to
    * fromEnvironment(). Return a [DartObjectImpl] object corresponding to the
    * evaluated result.
    */
   DartObjectImpl computeValueFromEnvironment(DartObject environmentValue,
       DartObjectImpl builtInDefaultValue,
@@ skipping 682 matching lines @@
 
   /**
    * Compute values for all of the constants in the compilation units that were
    * added.
    */
   void computeValues() {
     _constantsToCompute = _constantFinder.constantsToCompute;
     _annotations = _constantFinder.annotations;
     for (Element element in _constantsToCompute) {
       referenceGraph.addNode(element);
-      if (element is ParameterElement) {
-        if (element.initializer != null) {
-          Expression defaultValue =
-              (element as ConstVariableElement).constantInitializer;
-          if (defaultValue != null) {
-            ReferenceFinder parameterReferenceFinder =
-                new ReferenceFinder(element, referenceGraph);
-            defaultValue.accept(parameterReferenceFinder);
-          }
-        }
-      } else if (element is PotentiallyConstVariableElement) {
-        ReferenceFinder referenceFinder =
-            new ReferenceFinder(element, referenceGraph);
-        element.constantInitializer.accept(referenceFinder);
-      } else if (element is ConstructorElementImpl) {
-        element.isCycleFree = false;
-        ConstructorElement redirectedConstructor =
-            evaluationEngine.getConstRedirectedConstructor(element);
-        if (redirectedConstructor != null) {
-          ConstructorElement redirectedConstructorBase =
-              ConstantEvaluationEngine
-                  ._getConstructorBase(redirectedConstructor);
-          referenceGraph.addEdge(element, redirectedConstructorBase);
-          continue;
-        }
-        ReferenceFinder referenceFinder =
-            new ReferenceFinder(element, referenceGraph);
-        bool superInvocationFound = false;
-        List<ConstructorInitializer> initializers =
-            element.constantInitializers;
-        for (ConstructorInitializer initializer in initializers) {
-          if (initializer is SuperConstructorInvocation) {
-            superInvocationFound = true;
-          }
-          initializer.accept(referenceFinder);
-        }
-        if (!superInvocationFound) {
-          // No explicit superconstructor invocation found, so we need to
-          // manually insert a reference to the implicit superconstructor.
-          InterfaceType superclass =
-              (element.returnType as InterfaceType).superclass;
-          if (superclass != null && !superclass.isObject) {
-            ConstructorElement unnamedConstructor = ConstantEvaluationEngine
-                ._getConstructorBase(superclass.element.unnamedConstructor);
-            if (unnamedConstructor != null) {
-              referenceGraph.addEdge(element, unnamedConstructor);
-            }
-          }
-        }
-        for (FieldElement field in element.enclosingElement.fields) {
-          // Note: non-static const isn't allowed but we handle it anyway so that
-          // we won't be confused by incorrect code.
-          if ((field.isFinal || field.isConst) &&
-              !field.isStatic &&
-              field.initializer != null) {
-            referenceGraph.addEdge(element, field);
-          }
-        }
-        for (ParameterElement parameterElement in element.parameters) {
-          referenceGraph.addEdge(element, parameterElement);
-        }
-      } else {
-        // Should not happen.
-        assert(false);
-        AnalysisEngine.instance.logger.logError(
-            "Constant value computer trying to compute the value of a node of type ${element.runtimeType}");
-      }
+      evaluationEngine.computeDependencies(element, (Element dependency) {
+        referenceGraph.addEdge(element, dependency);
+      });
     }
     List<List<Element>> topologicalSort =
         referenceGraph.computeTopologicalSort();
     for (List<Element> constantsInCycle in topologicalSort) {
       if (constantsInCycle.length == 1) {
         _computeValueFor(constantsInCycle[0]);
       } else {
         for (Element constant in constantsInCycle) {
           _generateCycleError(constantsInCycle, constant);
         }
@@ skipping 3773 matching lines @@
   @override
   String toString() => "-unknown-";
 }
 
 /**
  * An object used to add reference information for a given variable to the
  * bi-directional mapping used to order the evaluation of constants.
  */
 class ReferenceFinder extends RecursiveAstVisitor<Object> {
   /**
-   * The element representing the construct that will be visited.
+   * The callback which should be used to report any dependencies that were
+   * found.
    */
-  final Element _source;
-
-  /**
-   * A graph in which the nodes are the constant variables and the edges are
-   * from each variable to the other constant variables that are referenced in
-   * the head's initializer.
-   */
-  final DirectedGraph<Element> _referenceGraph;
+  final ReferenceFinderCallback _callback;
 
   /**
    * Initialize a newly created reference finder to find references from a given
    * variable to other variables and to add those references to the given graph.
-   * The [source] is the element representing the variable whose initializer
-   * will be visited. The [referenceGraph] is a graph recording which variables
-   * (heads) reference which other variables (tails) in their initializers.
+   * The [_callback] will be invoked for every dependency found.
    */
-  ReferenceFinder(this._source, this._referenceGraph);
+  ReferenceFinder(this._callback);
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
       ConstructorElement constructor =
           ConstantEvaluationEngine._getConstructorBase(node.staticElement);
       if (constructor != null) {
-        _referenceGraph.addEdge(_source, constructor);
+        _callback(constructor);
       }
     }
     return super.visitInstanceCreationExpression(node);
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     super.visitRedirectingConstructorInvocation(node);
     ConstructorElement target =
         ConstantEvaluationEngine._getConstructorBase(node.staticElement);
     if (target != null && target.isConst) {
-      _referenceGraph.addEdge(_source, target);
+      _callback(target);
     }
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElement) {
       if (element.isConst) {
-        _referenceGraph.addEdge(_source, element);
+        _callback(element);
       }
     }
     return null;
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     super.visitSuperConstructorInvocation(node);
     ConstructorElement constructor =
         ConstantEvaluationEngine._getConstructorBase(node.staticElement);
     if (constructor != null && constructor.isConst) {
-      _referenceGraph.addEdge(_source, constructor);
+      _callback(constructor);
     }
     return null;
   }
 }
 
 /**
  * The state of an object representing a string.
  */
 class StringState extends InstanceState {
   /**
@@ skipping 201 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }