Add a task to the new task model for computing constant values.

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';
@@ skipping 290 matching lines @@
       return false;
     }
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
     }
     String name = argumentValues[0].stringValue;
     return isValidPublicSymbol(name);
   }
 
   /**
+   * Compute the constant value associated with the given [element].
+   */
+  void computeConstantValue(Element element) {
+    validator.beforeComputeValue(element);
+    if (element is ParameterElement) {
+      if (element.initializer != null) {
+        Expression defaultValue =
+            (element as PotentiallyConstVariableElement).constantInitializer;
+        if (defaultValue != null) {
+          RecordingErrorListener errorListener = new RecordingErrorListener();
+          ErrorReporter errorReporter =
+              new ErrorReporter(errorListener, element.source);
+          DartObjectImpl dartObject =
+              defaultValue.accept(new ConstantVisitor(this, errorReporter));
+          (element as ParameterElementImpl).evaluationResult =
+              new EvaluationResultImpl.con2(dartObject, errorListener.errors);
+        }
+      }
+    } else if (element is VariableElement) {
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      ErrorReporter errorReporter =
+          new ErrorReporter(errorListener, element.source);
+      DartObjectImpl dartObject =
+          (element as PotentiallyConstVariableElement).constantInitializer
+              .accept(new ConstantVisitor(this, errorReporter));
+      // Only check the type for truly const declarations (don't check final
+      // fields with initializers, since their types may be generic.  The type
+      // of the final field will be checked later, when the constructor is
+      // invoked).
+      if (dartObject != null && element.isConst) {
+        if (!runtimeTypeMatch(dartObject, element.type)) {
+          errorReporter.reportErrorForElement(
+              CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH, element, [
+            dartObject.type,
+            element.type
+          ]);
+        }
+      }
+      (element as VariableElementImpl).evaluationResult =
+          new EvaluationResultImpl.con2(dartObject, errorListener.errors);
+    } else if (element is ConstructorElement) {
+      // No evaluation needs to be done; constructor declarations are only in
+      // the dependency graph to ensure that any constants referred to in
+      // initializer lists and parameter defaults are evaluated before
+      // invocations of the constructor.  However we do need to annotate the
+      // element as being free of constant evaluation cycles so that later code
+      // will know that it is safe to evaluate.
+      (element as ConstructorElementImpl).isCycleFree = true;
+    } 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}");
+      return;
+    }
+  }
+
+  /**
    * 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;
@@ skipping 782 matching lines @@
 
   /**
    * Compute a value for the given [element].
    */
   void _computeValueFor(Element element) {
     if (!_constantsToCompute.contains(element)) {
       // Element is in the dependency graph but should have been computed by
       // a previous stage of analysis.
       return;
     }
-    evaluationEngine.validator.beforeComputeValue(element);
-    if (element is ParameterElement) {
-      if (element.initializer != null) {
-        Expression defaultValue =
-            (element as PotentiallyConstVariableElement).constantInitializer;
-        if (defaultValue != null) {
-          RecordingErrorListener errorListener = new RecordingErrorListener();
-          ErrorReporter errorReporter =
-              new ErrorReporter(errorListener, element.source);
-          DartObjectImpl dartObject = defaultValue
-              .accept(new ConstantVisitor(evaluationEngine, errorReporter));
-          (element as ParameterElementImpl).evaluationResult =
-              new EvaluationResultImpl.con2(dartObject, errorListener.errors);
-        }
-      }
-    } else if (element is VariableElement) {
-      RecordingErrorListener errorListener = new RecordingErrorListener();
-      ErrorReporter errorReporter =
-          new ErrorReporter(errorListener, element.source);
-      DartObjectImpl dartObject =
-          (element as PotentiallyConstVariableElement).constantInitializer
-              .accept(new ConstantVisitor(evaluationEngine, errorReporter));
-      // Only check the type for truly const declarations (don't check final
-      // fields with initializers, since their types may be generic.  The type
-      // of the final field will be checked later, when the constructor is
-      // invoked).
-      if (dartObject != null && element.isConst) {
-        if (!evaluationEngine.runtimeTypeMatch(dartObject, element.type)) {
-          errorReporter.reportErrorForElement(
-              CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH, element, [
-            dartObject.type,
-            element.type
-          ]);
-        }
-      }
-      (element as VariableElementImpl).evaluationResult =
-          new EvaluationResultImpl.con2(dartObject, errorListener.errors);
-    } else if (element is ConstructorElement) {
-      // No evaluation needs to be done; constructor declarations are only in
-      // the dependency graph to ensure that any constants referred to in
-      // initializer lists and parameter defaults are evaluated before
-      // invocations of the constructor.  However we do need to annotate the
-      // element as being free of constant evaluation cycles so that later code
-      // will know that it is safe to evaluate.
-      (element as ConstructorElementImpl).isCycleFree = true;
-    } 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}");
-      return;
-    }
+    evaluationEngine.computeConstantValue(element);
   }
 
   /**
    * Compute a value for the given annotation.
    */
   void _computeValueForAnnotation(Annotation constNode) {
     ElementAnnotationImpl elementAnnotation = constNode.elementAnnotation;
     // elementAnnotation is null if the annotation couldn't be resolved, in
     // which case we skip it.
     if (elementAnnotation != null) {
@@ skipping 3970 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;
 }